benjamyn/any-sync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP storage

Browse Source
This commit is contained in:
mcrakhman 2022-10-10 23:08:44 +02:00 committed by Mikhail Iudin
parent 8ba457bd12
commit 25260793c6
No known key found for this signature in database
GPG Key ID: FAAAA8BAABDFF1C0
15 changed files with 614 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
common/commonspace/diffservice/diffsyncer.go
View File

@ -107,7 +107,6 @@ func (d *diffSyncer) sendPushSpaceRequest(ctx context.Context, cl spacesyncproto
}
_, err = cl.PushSpace(ctx, &spacesyncproto.PushSpaceRequest{
SpaceId: d.spaceId,
SpaceHeader: header,
AclRoot: root,
})

8
common/commonspace/diffservice/diffsyncer_test.go
View File

@ -25,7 +25,7 @@ import (
type pushSpaceRequestMatcher struct {
spaceId string
aclRoot *aclrecordproto.RawACLRecordWithId
spaceHeader *spacesyncproto.SpaceHeader
spaceHeader *spacesyncproto.RawSpaceHeaderWithId
}
func (p pushSpaceRequestMatcher) Matches(x interface{}) bool {
@ -34,7 +34,7 @@ func (p pushSpaceRequestMatcher) Matches(x interface{}) bool {
return false
}
return res.SpaceId == p.spaceId && res.AclRoot == p.aclRoot && res.SpaceHeader == p.spaceHeader
return res.AclRoot == p.aclRoot && res.SpaceHeader == p.spaceHeader
}
func (p pushSpaceRequestMatcher) String() string {
@ -73,7 +73,7 @@ func (m mockPeer) NewStream(ctx context.Context, rpc string, enc drpc.Encoding)
func newPushSpaceRequestMatcher(
spaceId string,
aclRoot *aclrecordproto.RawACLRecordWithId,
spaceHeader *spacesyncproto.SpaceHeader) *pushSpaceRequestMatcher {
spaceHeader *spacesyncproto.RawSpaceHeaderWithId) *pushSpaceRequestMatcher {
return &pushSpaceRequestMatcher{
spaceId: spaceId,
aclRoot: aclRoot,
@ -125,7 +125,7 @@ func TestDiffSyncer_Sync(t *testing.T) {
t.Run("diff syncer sync space missing", func(t *testing.T) {
aclStorageMock := mock_aclstorage.NewMockListStorage(ctrl)
aclRoot := &aclrecordproto.RawACLRecordWithId{}
spaceHeader := &spacesyncproto.SpaceHeader{}
spaceHeader := &spacesyncproto.RawSpaceHeaderWithId{}
connectorMock.EXPECT().
GetResponsiblePeers(gomock.Any(), spaceId).

34
common/commonspace/payloads.go
View File

@ -39,11 +39,21 @@ func storagePayloadForSpaceCreate(payload SpaceCreatePayload) (storagePayload st
if err != nil {
return
}
id, err := cid.NewCIDFromBytes(marshalled)
signature, err := payload.SigningKey.Sign(marshalled)
if err != nil {
return
}
rawHeader := &spacesyncproto.RawSpaceHeader{SpaceHeader: marshalled, Signature: signature}
marshalled, err = rawHeader.Marshal()
if err != nil {
return
}
id, err := cid.NewCIDFromBytes(marshalled)
spaceId := NewSpaceId(id, payload.ReplicationKey)
rawHeaderWithId := &spacesyncproto.RawSpaceHeaderWithId{
RawHeader: marshalled,
Id: spaceId,
}
// encrypting read key
hasher := fnv.New64()
@ -74,9 +84,8 @@ func storagePayloadForSpaceCreate(payload SpaceCreatePayload) (storagePayload st
// creating storage
storagePayload = storage.SpaceStorageCreatePayload{
RecWithId: rawWithId,
SpaceHeader: header,
Id: id,
RecWithId: rawWithId,
SpaceHeaderWithId: rawHeaderWithId,
}
return
}
@ -118,11 +127,21 @@ func storagePayloadForSpaceDerive(payload SpaceDerivePayload) (storagePayload st
if err != nil {
return
}
id, err := cid.NewCIDFromBytes(marshalled)
signature, err := payload.SigningKey.Sign(marshalled)
if err != nil {
return
}
rawHeader := &spacesyncproto.RawSpaceHeader{SpaceHeader: marshalled, Signature: signature}
marshalled, err = rawHeader.Marshal()
if err != nil {
return
}
id, err := cid.NewCIDFromBytes(marshalled)
spaceId := NewSpaceId(id, repKey)
rawHeaderWithId := &spacesyncproto.RawSpaceHeaderWithId{
RawHeader: marshalled,
Id: spaceId,
}
// deriving and encrypting read key
readKey, err := aclrecordproto.ACLReadKeyDerive(signPrivKey, encPrivKey)
@ -157,9 +176,8 @@ func storagePayloadForSpaceDerive(payload SpaceDerivePayload) (storagePayload st
// creating storage
storagePayload = storage.SpaceStorageCreatePayload{
RecWithId: rawWithId,
SpaceHeader: header,
Id: id,
RecWithId: rawWithId,
SpaceHeaderWithId: rawHeaderWithId,
}
return
}

4
common/commonspace/service.go
View File

@ -62,7 +62,7 @@ func (s *service) CreateSpace(
return
}
return s.GetSpace(ctx, storageCreate.Id)
return s.GetSpace(ctx, storageCreate.SpaceHeaderWithId.GetId())
}
func (s *service) DeriveSpace(
@ -78,7 +78,7 @@ func (s *service) DeriveSpace(
return
}
return s.GetSpace(ctx, storageCreate.Id)
return s.GetSpace(ctx, storageCreate.SpaceHeaderWithId.GetId())
}
func (s *service) GetSpace(ctx context.Context, id string) (Space, error) {

13
common/commonspace/spacesyncproto/protos/spacesync.proto
View File

@ -102,8 +102,7 @@ message ObjectErrorResponse {
// PushSpaceRequest is a request to add space on a node containing only one acl record
message PushSpaceRequest {
string spaceId = 1;
SpaceHeader spaceHeader = 2;
RawSpaceHeaderWithId spaceHeader = 2;
aclrecord.RawACLRecordWithId aclRoot = 3;
}
@ -118,3 +117,13 @@ message SpaceHeader {
uint64 replicationKey = 4;
bytes seed = 5;
}
message RawSpaceHeader {
bytes spaceHeader = 1;
bytes signature = 2;
}
message RawSpaceHeaderWithId {
bytes rawHeader = 1;
string id = 2;
}

626
common/commonspace/spacesyncproto/spacesync.pb.go
View File

@ -747,8 +747,7 @@ func (m *ObjectErrorResponse) GetError() string {
// PushSpaceRequest is a request to add space on a node containing only one acl record
type PushSpaceRequest struct {
SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
SpaceHeader *SpaceHeader `protobuf:"bytes,2,opt,name=spaceHeader,proto3" json:"spaceHeader,omitempty"`
SpaceHeader *RawSpaceHeaderWithId `protobuf:"bytes,2,opt,name=spaceHeader,proto3" json:"spaceHeader,omitempty"`
AclRoot *aclrecordproto.RawACLRecordWithId `protobuf:"bytes,3,opt,name=aclRoot,proto3" json:"aclRoot,omitempty"`
}
@ -785,14 +784,7 @@ func (m *PushSpaceRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_PushSpaceRequest proto.InternalMessageInfo
func (m *PushSpaceRequest) GetSpaceId() string {
if m != nil {
return m.SpaceId
}
return ""
}
func (m *PushSpaceRequest) GetSpaceHeader() *SpaceHeader {
func (m *PushSpaceRequest) GetSpaceHeader() *RawSpaceHeaderWithId {
if m != nil {
return m.SpaceHeader
}
@ -920,6 +912,110 @@ func (m *SpaceHeader) GetSeed() []byte {
return nil
}
type RawSpaceHeader struct {
SpaceHeader []byte `protobuf:"bytes,1,opt,name=spaceHeader,proto3" json:"spaceHeader,omitempty"`
Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
}
func (m *RawSpaceHeader) Reset() { *m = RawSpaceHeader{} }
func (m *RawSpaceHeader) String() string { return proto.CompactTextString(m) }
func (*RawSpaceHeader) ProtoMessage() {}
func (*RawSpaceHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_5855f4ef9cf24cdb, []int{14}
}
func (m *RawSpaceHeader) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *RawSpaceHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_RawSpaceHeader.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *RawSpaceHeader) XXX_Merge(src proto.Message) {
xxx_messageInfo_RawSpaceHeader.Merge(m, src)
}
func (m *RawSpaceHeader) XXX_Size() int {
return m.Size()
}
func (m *RawSpaceHeader) XXX_DiscardUnknown() {
xxx_messageInfo_RawSpaceHeader.DiscardUnknown(m)
}
var xxx_messageInfo_RawSpaceHeader proto.InternalMessageInfo
func (m *RawSpaceHeader) GetSpaceHeader() []byte {
if m != nil {
return m.SpaceHeader
}
return nil
}
func (m *RawSpaceHeader) GetSignature() []byte {
if m != nil {
return m.Signature
}
return nil
}
type RawSpaceHeaderWithId struct {
RawHeader []byte `protobuf:"bytes,1,opt,name=rawHeader,proto3" json:"rawHeader,omitempty"`
Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
}
func (m *RawSpaceHeaderWithId) Reset() { *m = RawSpaceHeaderWithId{} }
func (m *RawSpaceHeaderWithId) String() string { return proto.CompactTextString(m) }
func (*RawSpaceHeaderWithId) ProtoMessage() {}
func (*RawSpaceHeaderWithId) Descriptor() ([]byte, []int) {
return fileDescriptor_5855f4ef9cf24cdb, []int{15}
}
func (m *RawSpaceHeaderWithId) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *RawSpaceHeaderWithId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_RawSpaceHeaderWithId.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *RawSpaceHeaderWithId) XXX_Merge(src proto.Message) {
xxx_messageInfo_RawSpaceHeaderWithId.Merge(m, src)
}
func (m *RawSpaceHeaderWithId) XXX_Size() int {
return m.Size()
}
func (m *RawSpaceHeaderWithId) XXX_DiscardUnknown() {
xxx_messageInfo_RawSpaceHeaderWithId.DiscardUnknown(m)
}
var xxx_messageInfo_RawSpaceHeaderWithId proto.InternalMessageInfo
func (m *RawSpaceHeaderWithId) GetRawHeader() []byte {
if m != nil {
return m.RawHeader
}
return nil
}
func (m *RawSpaceHeaderWithId) GetId() string {
if m != nil {
return m.Id
}
return ""
}
func init() {
proto.RegisterEnum("anySpace.ErrCodes", ErrCodes_name, ErrCodes_value)
proto.RegisterType((*HeadSyncRange)(nil), "anySpace.HeadSyncRange")
@ -936,6 +1032,8 @@ func init() {
proto.RegisterType((*PushSpaceRequest)(nil), "anySpace.PushSpaceRequest")
proto.RegisterType((*PushSpaceResponse)(nil), "anySpace.PushSpaceResponse")
proto.RegisterType((*SpaceHeader)(nil), "anySpace.SpaceHeader")
proto.RegisterType((*RawSpaceHeader)(nil), "anySpace.RawSpaceHeader")
proto.RegisterType((*RawSpaceHeaderWithId)(nil), "anySpace.RawSpaceHeaderWithId")
}
func init() {
@ -943,65 +1041,68 @@ func init() {
}
var fileDescriptor_5855f4ef9cf24cdb = []byte{
// 919 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0xcd, 0x8e, 0x1b, 0x45,
0x10, 0xf6, 0x78, 0xbd, 0x6b, 0xbb, 0xbc, 0x3f, 0x4e, 0x87, 0x0d, 0x83, 0x43, 0x1c, 0x33, 0x07,
0xb4, 0x02, 0xb1, 0x46, 0xe6, 0x10, 0x60, 0x91, 0x50, 0xb2, 0x78, 0x65, 0x2b, 0xe4, 0x47, 0xbd,
0x09, 0x48, 0x88, 0x4b, 0x67, 0xa6, 0xd6, 0x1e, 0x32, 0x9e, 0x1e, 0xa6, 0xdb, 0x6c, 0xfc, 0x04,
0x5c, 0x40, 0xe2, 0x09, 0x90, 0x78, 0x16, 0x2e, 0x1c, 0x73, 0xcc, 0x11, 0xed, 0xbe, 0x08, 0xea,
0x9a, 0x19, 0xcf, 0xd8, 0x4c, 0xb2, 0xc7, 0x5c, 0x3c, 0x5d, 0x55, 0x5f, 0x55, 0x7f, 0xf5, 0xd3,
0xdd, 0x86, 0xcf, 0x5d, 0x39, 0x9b, 0xc9, 0xb0, 0x9f, 0x7c, 0x54, 0x24, 0x5c, 0xec, 0xd3, 0xaf,
0x5a, 0x84, 0x6e, 0x14, 0x4b, 0x2d, 0xfb, 0xf4, 0xab, 0x72, 0xed, 0x21, 0x29, 0x58, 0x43, 0x84,
0x8b, 0x53, 0xa3, 0xeb, 0xf4, 0xa3, 0xe7, 0x93, 0xbe, 0x70, 0x83, 0xbe, 0x8e, 0x11, 0xdd, 0xa9,
0x08, 0x27, 0xb8, 0xe2, 0x99, 0xab, 0x13, 0xd7, 0xce, 0x27, 0x99, 0x83, 0x70, 0x83, 0x18, 0x5d,
0x19, 0x7b, 0x2b, 0xf8, 0xa5, 0x36, 0x81, 0x3b, 0x63, 0xd8, 0x19, 0xa1, 0xf0, 0x4e, 0x17, 0xa1,
0xcb, 0x4d, 0x14, 0xc6, 0xa0, 0x76, 0x16, 0xcb, 0x99, 0x6d, 0xf5, 0xac, 0x83, 0x1a, 0xa7, 0x35,
0xdb, 0x85, 0xaa, 0x96, 0x76, 0x95, 0x34, 0x55, 0x2d, 0xd9, 0x3b, 0xb0, 0x19, 0xf8, 0x33, 0x5f,
0xdb, 0x1b, 0x3d, 0xeb, 0x60, 0x87, 0x27, 0x82, 0x73, 0x0e, 0xbb, 0xcb, 0x50, 0xa8, 0xe6, 0x81,
0x36, 0xb1, 0xa6, 0x42, 0x4d, 0x29, 0xd6, 0x36, 0xa7, 0x35, 0x3b, 0x82, 0x06, 0x06, 0x38, 0xc3,
0x50, 0x2b, 0xbb, 0xda, 0xdb, 0x38, 0x68, 0x0d, 0x6e, 0x1f, 0x66, 0xd9, 0x1e, 0xae, 0xfa, 0x0f,
0x13, 0x1c, 0x5f, 0x3a, 0x98, 0x8d, 0x5d, 0x39, 0x0f, 0x97, 0x1b, 0x93, 0xe0, 0x1c, 0xc1, 0x7e,
0xa9, 0xa3, 0xe1, 0xed, 0x7b, 0xb4, 0x7b, 0x93, 0x57, 0x7d, 0x8f, 0xf8, 0xa0, 0xf0, 0x28, 0x93,
0x26, 0xa7, 0xb5, 0xf3, 0x23, 0xec, 0xe5, 0xce, 0x3f, 0xcf, 0x51, 0x69, 0x66, 0x43, 0x9d, 0x1a,
0x32, 0xce, 0x7c, 0x33, 0x91, 0xf5, 0x61, 0x2b, 0x36, 0x55, 0xca, 0xa8, 0xbf, 0x5b, 0x42, 0xdd,
0xd8, 0x79, 0x0a, 0x73, 0x4e, 0xa0, 0x5d, 0xa0, 0x16, 0xc9, 0x50, 0x21, 0x1b, 0x40, 0x3d, 0x26,
0x9a, 0xca, 0xb6, 0x28, 0x8a, 0xfd, 0xba, 0x02, 0xf0, 0x0c, 0xe8, 0x5c, 0x58, 0x70, 0xed, 0xd1,
0xb3, 0x9f, 0xd0, 0xd5, 0xc6, 0xfa, 0x00, 0x95, 0x12, 0x13, 0x7c, 0x03, 0xd1, 0x2f, 0xa1, 0xee,
0xca, 0x50, 0x63, 0xa8, 0x29, 0xd9, 0xd6, 0xa0, 0x97, 0xef, 0x91, 0xc7, 0x39, 0x4e, 0x20, 0xdf,
0x89, 0x60, 0x8e, 0x3c, 0x73, 0x60, 0x5f, 0x03, 0xc4, 0x52, 0xea, 0x63, 0x9a, 0x2a, 0xaa, 0xb4,
0xe9, 0x51, 0x61, 0xd0, 0xb8, 0x38, 0x7f, 0x12, 0x23, 0x26, 0x80, 0xef, 0x7d, 0x3d, 0x1d, 0x7b,
0xbc, 0xe0, 0xc2, 0x6e, 0xc0, 0x96, 0x41, 0x8f, 0x3d, 0xbb, 0x46, 0xac, 0x52, 0x89, 0x75, 0x01,
0x74, 0x2c, 0xdc, 0xe7, 0x7e, 0x38, 0x19, 0x7b, 0xf6, 0x26, 0xd9, 0x0a, 0x1a, 0xe7, 0xef, 0x2a,
0xdc, 0x28, 0x27, 0xc7, 0xbe, 0x02, 0x30, 0xdd, 0x7a, 0x1a, 0x79, 0x42, 0x23, 0x25, 0xdb, 0x1a,
0x74, 0xd6, 0x53, 0x1a, 0x2d, 0x11, 0xa3, 0x0a, 0x2f, 0xe0, 0xd9, 0x7d, 0xd8, 0x3b, 0x9b, 0x07,
0x41, 0xa1, 0xc7, 0x69, 0x55, 0x6e, 0xaf, 0x87, 0x38, 0x59, 0x85, 0x8d, 0x2a, 0x7c, 0xdd, 0x93,
0x3d, 0x84, 0x76, 0xae, 0x4a, 0x5a, 0x9a, 0x16, 0xa9, 0xf7, 0xfa, 0x68, 0x09, 0x6e, 0x54, 0xe1,
0xff, 0xf3, 0x65, 0x43, 0xd8, 0xc1, 0x38, 0x96, 0xf1, 0x32, 0x58, 0x8d, 0x82, 0xdd, 0x5a, 0x0f,
0x36, 0x2c, 0x82, 0x46, 0x15, 0xbe, 0xea, 0x75, 0xaf, 0x0e, 0x9b, 0xbf, 0x98, 0x52, 0x39, 0xbf,
0x5a, 0xd0, 0x5e, 0xaf, 0x87, 0x39, 0x38, 0xa6, 0x1e, 0xc9, 0xc4, 0x35, 0x79, 0x22, 0xb0, 0x2f,
0xa0, 0x9e, 0xb4, 0x34, 0x3f, 0x8a, 0x57, 0xb4, 0x39, 0xc3, 0x33, 0x07, 0xb6, 0x55, 0x28, 0x22,
0x35, 0x95, 0xfa, 0xb1, 0xd0, 0x53, 0x7b, 0x83, 0xe2, 0xae, 0xe8, 0x9c, 0xdf, 0x2c, 0xd8, 0x2f,
0x2d, 0xeb, 0xdb, 0xa1, 0xf3, 0xbb, 0x95, 0x8d, 0xd7, 0x7a, 0x5f, 0xde, 0x0e, 0x9f, 0x8f, 0xe1,
0x7a, 0x49, 0x67, 0x0d, 0x17, 0xea, 0x6c, 0x7a, 0xa4, 0x13, 0xc1, 0xf9, 0xd3, 0x82, 0xf6, 0xe3,
0xb9, 0x9a, 0xd2, 0x44, 0x5c, 0x7d, 0x51, 0xdd, 0x81, 0x16, 0x2d, 0xcd, 0x08, 0x60, 0x9c, 0x4e,
0xfb, 0x7e, 0x3e, 0x52, 0xa7, 0xb9, 0x91, 0x17, 0x91, 0xec, 0x0e, 0xd4, 0x85, 0x1b, 0x70, 0x29,
0x75, 0x3a, 0xd4, 0xb7, 0x0e, 0xf3, 0x27, 0x83, 0x8b, 0xf3, 0xbb, 0xc7, 0xdf, 0x72, 0x12, 0xb2,
0x8c, 0x53, 0xb4, 0x73, 0x1d, 0xae, 0x15, 0xf8, 0x25, 0xb9, 0x38, 0x7f, 0x59, 0xd0, 0x2a, 0x6c,
0xc5, 0x3a, 0xd0, 0xf0, 0x3d, 0x0c, 0xb5, 0xaf, 0x17, 0xe9, 0xa3, 0xb0, 0x94, 0xd9, 0xfb, 0xd0,
0xd4, 0xfe, 0x0c, 0x95, 0x16, 0xb3, 0x88, 0x08, 0x6f, 0xf0, 0x5c, 0x61, 0xac, 0x44, 0xf3, 0xc9,
0x22, 0x4a, 0x8e, 0x5b, 0x93, 0xe7, 0x0a, 0xf6, 0x21, 0xec, 0xc6, 0x18, 0x05, 0xbe, 0x2b, 0xb4,
0x2f, 0xc3, 0xfb, 0xb8, 0xa0, 0x43, 0x54, 0xe3, 0x6b, 0x5a, 0xf3, 0x00, 0x28, 0xc4, 0xe4, 0xee,
0xd9, 0xe6, 0xb4, 0xfe, 0xe8, 0x21, 0x34, 0x86, 0x71, 0x7c, 0x2c, 0x3d, 0x54, 0x6c, 0x17, 0xe0,
0x69, 0x88, 0x2f, 0x22, 0x74, 0x35, 0x7a, 0xed, 0x0a, 0x6b, 0xc3, 0x36, 0xd1, 0x7f, 0xe0, 0x2b,
0xe5, 0x87, 0x93, 0xb6, 0xc5, 0xf6, 0xd2, 0x84, 0x86, 0x2f, 0x7c, 0xa5, 0x55, 0xbb, 0x6a, 0x14,
0xd4, 0xbf, 0x47, 0x67, 0x67, 0x0a, 0x75, 0xdb, 0x1b, 0xbc, 0xb2, 0x60, 0x93, 0x20, 0xec, 0x2e,
0x34, 0xb2, 0xfb, 0x9c, 0xbd, 0x57, 0x76, 0xc7, 0x53, 0x17, 0x3b, 0x9d, 0xd2, 0xeb, 0x3f, 0x19,
0x86, 0x6f, 0xa0, 0xb9, 0xac, 0x2a, 0x2b, 0x00, 0xd7, 0x47, 0xa1, 0x73, 0xb3, 0xd4, 0x96, 0x46,
0x39, 0x81, 0xad, 0x53, 0x1d, 0xa3, 0x98, 0xb1, 0x9b, 0x65, 0xcf, 0x40, 0xfa, 0x9c, 0x74, 0xde,
0x64, 0x3c, 0xb0, 0x3e, 0xb5, 0xee, 0x1d, 0xfd, 0x73, 0xd1, 0xb5, 0x5e, 0x5e, 0x74, 0xad, 0x7f,
0x2f, 0xba, 0xd6, 0x1f, 0x97, 0xdd, 0xca, 0xcb, 0xcb, 0x6e, 0xe5, 0xd5, 0x65, 0xb7, 0xf2, 0xc3,
0x07, 0x57, 0xfe, 0xd5, 0x79, 0xb6, 0x45, 0x9f, 0xcf, 0xfe, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xce,
0x99, 0xdc, 0xc5, 0x16, 0x09, 0x00, 0x00,
// 965 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x56, 0xcd, 0x92, 0xdb, 0x44,
0x10, 0xb6, 0xbc, 0x3f, 0xb6, 0xdb, 0x5e, 0xaf, 0x33, 0xf9, 0x41, 0x38, 0xc4, 0x31, 0x3a, 0x50,
0x5b, 0x50, 0xac, 0x29, 0x73, 0xe0, 0x67, 0xa9, 0x82, 0x64, 0xe3, 0x2d, 0xbb, 0x42, 0x92, 0xad,
0xd9, 0x04, 0xaa, 0x28, 0x2e, 0x13, 0x69, 0xd6, 0x16, 0x91, 0x35, 0x62, 0x66, 0x8c, 0xe3, 0x27,
0xe0, 0x02, 0x55, 0xbc, 0x02, 0xcf, 0xc2, 0x85, 0x63, 0x8e, 0x39, 0x52, 0xbb, 0x2f, 0x42, 0x4d,
0x4b, 0xb2, 0x24, 0x47, 0x49, 0x8e, 0xb9, 0xd8, 0xd3, 0x3d, 0x5f, 0xf7, 0x7c, 0xf3, 0x75, 0x8f,
0xdb, 0xf0, 0xa5, 0x2b, 0xe6, 0x73, 0x11, 0x0e, 0xe2, 0x2f, 0x15, 0x31, 0x97, 0x0f, 0xf0, 0x53,
0xad, 0x42, 0x37, 0x92, 0x42, 0x8b, 0x01, 0x7e, 0xaa, 0xcc, 0x7b, 0x88, 0x0e, 0x52, 0x67, 0xe1,
0xea, 0xcc, 0xf8, 0xba, 0x83, 0xe8, 0xd9, 0x74, 0xc0, 0xdc, 0x60, 0xa0, 0x25, 0xe7, 0xee, 0x8c,
0x85, 0x53, 0x5e, 0x88, 0xcc, 0xdc, 0x71, 0x68, 0xf7, 0xd3, 0x34, 0x80, 0xb9, 0x81, 0xe4, 0xae,
0x90, 0x5e, 0x01, 0xbf, 0xf6, 0xc6, 0x70, 0x67, 0x02, 0x7b, 0x63, 0xce, 0xbc, 0xb3, 0x55, 0xe8,
0x52, 0x93, 0x85, 0x10, 0xd8, 0x3e, 0x97, 0x62, 0x6e, 0x5b, 0x7d, 0xeb, 0x60, 0x9b, 0xe2, 0x9a,
0xb4, 0xa1, 0xaa, 0x85, 0x5d, 0x45, 0x4f, 0x55, 0x0b, 0x72, 0x0d, 0x76, 0x02, 0x7f, 0xee, 0x6b,
0x7b, 0xab, 0x6f, 0x1d, 0xec, 0xd1, 0xd8, 0x70, 0x96, 0xd0, 0x5e, 0xa7, 0xe2, 0x6a, 0x11, 0x68,
0x93, 0x6b, 0xc6, 0xd4, 0x0c, 0x73, 0xb5, 0x28, 0xae, 0xc9, 0x11, 0xd4, 0x79, 0xc0, 0xe7, 0x3c,
0xd4, 0xca, 0xae, 0xf6, 0xb7, 0x0e, 0x9a, 0xc3, 0xdb, 0x87, 0xe9, 0x6d, 0x0f, 0x8b, 0xf1, 0xa3,
0x18, 0x47, 0xd7, 0x01, 0xe6, 0x60, 0x57, 0x2c, 0xc2, 0xf5, 0xc1, 0x68, 0x38, 0x47, 0x70, 0xbd,
0x34, 0xd0, 0xf0, 0xf6, 0x3d, 0x3c, 0xbd, 0x41, 0xab, 0xbe, 0x87, 0x7c, 0x38, 0xf3, 0xf0, 0x26,
0x0d, 0x8a, 0x6b, 0xe7, 0x67, 0xd8, 0xcf, 0x82, 0x7f, 0x5d, 0x70, 0xa5, 0x89, 0x0d, 0x35, 0x2c,
0xc8, 0x24, 0x8d, 0x4d, 0x4d, 0x32, 0x80, 0x5d, 0x69, 0x54, 0x4a, 0xa9, 0xbf, 0x57, 0x42, 0xdd,
0xec, 0xd3, 0x04, 0xe6, 0x9c, 0x40, 0x27, 0x47, 0x2d, 0x12, 0xa1, 0xe2, 0x64, 0x08, 0x35, 0x89,
0x34, 0x95, 0x6d, 0x61, 0x16, 0xfb, 0x75, 0x02, 0xd0, 0x14, 0xe8, 0x5c, 0x58, 0x70, 0xe5, 0xd1,
0xd3, 0x5f, 0xb8, 0xab, 0xcd, 0xee, 0x03, 0xae, 0x14, 0x9b, 0xf2, 0x37, 0x10, 0xfd, 0x1a, 0x6a,
0xae, 0x08, 0x35, 0x0f, 0x35, 0x5e, 0xb6, 0x39, 0xec, 0x67, 0x67, 0x64, 0x79, 0x8e, 0x63, 0xc8,
0x0f, 0x2c, 0x58, 0x70, 0x9a, 0x06, 0x90, 0x6f, 0x01, 0xa4, 0x10, 0xfa, 0x18, 0xbb, 0x0a, 0x95,
0x36, 0x35, 0xca, 0x35, 0x1a, 0x65, 0xcb, 0xc7, 0x92, 0xf3, 0x18, 0xf0, 0xa3, 0xaf, 0x67, 0x13,
0x8f, 0xe6, 0x42, 0xc8, 0x0d, 0xd8, 0x35, 0xe8, 0x89, 0x67, 0x6f, 0x23, 0xab, 0xc4, 0x22, 0x3d,
0x00, 0x2d, 0x99, 0xfb, 0xcc, 0x0f, 0xa7, 0x13, 0xcf, 0xde, 0xc1, 0xbd, 0x9c, 0xc7, 0xf9, 0xa7,
0x0a, 0x37, 0xca, 0xc9, 0x91, 0x6f, 0x00, 0x4c, 0xb5, 0x9e, 0x44, 0x1e, 0xd3, 0x1c, 0x2f, 0xdb,
0x1c, 0x76, 0x37, 0xaf, 0x34, 0x5e, 0x23, 0xc6, 0x15, 0x9a, 0xc3, 0x93, 0xfb, 0xb0, 0x7f, 0xbe,
0x08, 0x82, 0x5c, 0x8d, 0x13, 0x55, 0x6e, 0x6f, 0xa6, 0x38, 0x29, 0xc2, 0xc6, 0x15, 0xba, 0x19,
0x49, 0x1e, 0x42, 0x27, 0x73, 0xc5, 0x25, 0x4d, 0x44, 0xea, 0xbf, 0x3e, 0x5b, 0x8c, 0x1b, 0x57,
0xe8, 0x2b, 0xb1, 0x64, 0x04, 0x7b, 0x5c, 0x4a, 0x21, 0xd7, 0xc9, 0xb6, 0x31, 0xd9, 0xad, 0xcd,
0x64, 0xa3, 0x3c, 0x68, 0x5c, 0xa1, 0xc5, 0xa8, 0xbb, 0x35, 0xd8, 0xf9, 0xcd, 0x48, 0xe5, 0xfc,
0x6e, 0x41, 0x67, 0x53, 0x0f, 0xf3, 0x70, 0x8c, 0x1e, 0x71, 0xc7, 0x35, 0x68, 0x6c, 0x90, 0xaf,
0xa0, 0x16, 0x97, 0x34, 0x7b, 0x8a, 0x6f, 0x29, 0x73, 0x8a, 0x27, 0x0e, 0xb4, 0x54, 0xc8, 0x22,
0x35, 0x13, 0xfa, 0x94, 0xe9, 0x99, 0xbd, 0x85, 0x79, 0x0b, 0x3e, 0xe7, 0x0f, 0x0b, 0xae, 0x97,
0xca, 0xfa, 0x6e, 0xe8, 0xfc, 0x69, 0xa5, 0xed, 0xb5, 0x59, 0x97, 0x77, 0xc3, 0xe7, 0x13, 0xb8,
0x5a, 0x52, 0x59, 0xc3, 0x05, 0x2b, 0x9b, 0x3c, 0xe9, 0xd8, 0x30, 0xe4, 0x3b, 0xa7, 0x0b, 0x35,
0xc3, 0x8e, 0x48, 0x65, 0xfc, 0x0e, 0x9a, 0xf8, 0xe0, 0x4d, 0xa1, 0xb9, 0x4c, 0x7a, 0xba, 0x97,
0x35, 0x0e, 0x65, 0xcb, 0xb3, 0x6c, 0x3f, 0xe1, 0x98, 0x0f, 0x21, 0x5f, 0x40, 0x8d, 0xb9, 0x01,
0x15, 0x42, 0x27, 0x3d, 0x7c, 0xeb, 0x30, 0x9b, 0x10, 0x94, 0x2d, 0xef, 0x1c, 0x7f, 0x4f, 0xd1,
0x48, 0x2f, 0x98, 0xa0, 0x9d, 0xab, 0x70, 0x25, 0x47, 0x27, 0xa6, 0xee, 0xfc, 0x6d, 0x41, 0x33,
0x77, 0x20, 0xe9, 0x42, 0xdd, 0xf7, 0x78, 0xa8, 0x7d, 0xbd, 0x4a, 0x66, 0xc0, 0xda, 0x26, 0x1f,
0x40, 0x43, 0xfb, 0x73, 0xae, 0x34, 0x9b, 0x47, 0xc8, 0x7c, 0x8b, 0x66, 0x0e, 0xb3, 0x8b, 0x34,
0x1f, 0xaf, 0xa2, 0xf8, 0x75, 0x35, 0x68, 0xe6, 0x20, 0x1f, 0x41, 0x5b, 0xf2, 0x28, 0xf0, 0x5d,
0xa6, 0x7d, 0x11, 0xde, 0xe7, 0x2b, 0x7c, 0x33, 0xdb, 0x74, 0xc3, 0x6b, 0x7e, 0xef, 0x15, 0xe7,
0xf1, 0x4f, 0x4d, 0x8b, 0xe2, 0xda, 0x39, 0x85, 0x76, 0x51, 0x16, 0xd2, 0x2f, 0xaa, 0x18, 0x13,
0x2d, 0xa8, 0x64, 0xd8, 0xf8, 0xd3, 0x90, 0xe9, 0x85, 0xe4, 0xc8, 0xb5, 0x45, 0x33, 0x87, 0x73,
0x0f, 0xae, 0x95, 0x09, 0x6d, 0xa2, 0x24, 0x5b, 0x16, 0xb2, 0x66, 0x8e, 0x64, 0x36, 0x55, 0xd3,
0xd9, 0xf4, 0xf1, 0x43, 0xa8, 0x8f, 0xa4, 0x3c, 0x16, 0x1e, 0x57, 0xa4, 0x0d, 0xf0, 0x24, 0xe4,
0xcf, 0x23, 0xee, 0x6a, 0xee, 0x75, 0x2a, 0xa4, 0x03, 0x2d, 0x4c, 0xff, 0xc0, 0x57, 0xca, 0x0f,
0xa7, 0x1d, 0x8b, 0xec, 0x27, 0x42, 0x8f, 0x9e, 0xfb, 0x4a, 0xab, 0x4e, 0xd5, 0x38, 0xb0, 0x8d,
0x1e, 0x9d, 0x9f, 0x2b, 0xae, 0x3b, 0xde, 0xf0, 0xa5, 0x05, 0x3b, 0x08, 0x21, 0x77, 0xa0, 0x9e,
0x8e, 0x15, 0xf2, 0x7e, 0xd9, 0xa8, 0xc1, 0x66, 0xea, 0x76, 0x4b, 0xa7, 0x50, 0xdc, 0x93, 0xf7,
0xa0, 0xb1, 0xae, 0x36, 0xc9, 0x01, 0x37, 0x3b, 0xb2, 0x7b, 0xb3, 0x74, 0x2f, 0xc9, 0x72, 0x02,
0xbb, 0x67, 0x5a, 0x72, 0x36, 0x27, 0x37, 0xcb, 0xa6, 0x51, 0x32, 0xd5, 0xba, 0x6f, 0xda, 0x3c,
0xb0, 0x3e, 0xb3, 0xee, 0x1e, 0xfd, 0x7b, 0xd1, 0xb3, 0x5e, 0x5c, 0xf4, 0xac, 0xff, 0x2e, 0x7a,
0xd6, 0x5f, 0x97, 0xbd, 0xca, 0x8b, 0xcb, 0x5e, 0xe5, 0xe5, 0x65, 0xaf, 0xf2, 0xd3, 0x87, 0x6f,
0xfd, 0xc7, 0xf5, 0x74, 0x17, 0xbf, 0x3e, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x2e, 0x4f, 0xd9,
0xa3, 0x9d, 0x09, 0x00, 0x00,
}
func (m *HeadSyncRange) Marshal() (dAtA []byte, err error) {
@ -1632,13 +1733,6 @@ func (m *PushSpaceRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x12
}
if len(m.SpaceId) > 0 {
i -= len(m.SpaceId)
copy(dAtA[i:], m.SpaceId)
i = encodeVarintSpacesync(dAtA, i, uint64(len(m.SpaceId)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
@ -1719,6 +1813,80 @@ func (m *SpaceHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *RawSpaceHeader) 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 *RawSpaceHeader) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *RawSpaceHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Signature) > 0 {
i -= len(m.Signature)
copy(dAtA[i:], m.Signature)
i = encodeVarintSpacesync(dAtA, i, uint64(len(m.Signature)))
i--
dAtA[i] = 0x12
}
if len(m.SpaceHeader) > 0 {
i -= len(m.SpaceHeader)
copy(dAtA[i:], m.SpaceHeader)
i = encodeVarintSpacesync(dAtA, i, uint64(len(m.SpaceHeader)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *RawSpaceHeaderWithId) 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 *RawSpaceHeaderWithId) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *RawSpaceHeaderWithId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Id) > 0 {
i -= len(m.Id)
copy(dAtA[i:], m.Id)
i = encodeVarintSpacesync(dAtA, i, uint64(len(m.Id)))
i--
dAtA[i] = 0x12
}
if len(m.RawHeader) > 0 {
i -= len(m.RawHeader)
copy(dAtA[i:], m.RawHeader)
i = encodeVarintSpacesync(dAtA, i, uint64(len(m.RawHeader)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintSpacesync(dAtA []byte, offset int, v uint64) int {
offset -= sovSpacesync(v)
base := offset
@ -2010,10 +2178,6 @@ func (m *PushSpaceRequest) Size() (n int) {
}
var l int
_ = l
l = len(m.SpaceId)
if l > 0 {
n += 1 + l + sovSpacesync(uint64(l))
}
if m.SpaceHeader != nil {
l = m.SpaceHeader.Size()
n += 1 + l + sovSpacesync(uint64(l))
@ -2061,6 +2225,40 @@ func (m *SpaceHeader) Size() (n int) {
return n
}
func (m *RawSpaceHeader) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.SpaceHeader)
if l > 0 {
n += 1 + l + sovSpacesync(uint64(l))
}
l = len(m.Signature)
if l > 0 {
n += 1 + l + sovSpacesync(uint64(l))
}
return n
}
func (m *RawSpaceHeaderWithId) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.RawHeader)
if l > 0 {
n += 1 + l + sovSpacesync(uint64(l))
}
l = len(m.Id)
if l > 0 {
n += 1 + l + sovSpacesync(uint64(l))
}
return n
}
func sovSpacesync(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
@ -3588,38 +3786,6 @@ func (m *PushSpaceRequest) Unmarshal(dAtA []byte) error {
return fmt.Errorf("proto: PushSpaceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSpacesync
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthSpacesync
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSpacesync
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.SpaceId = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SpaceHeader", wireType)
@ -3650,7 +3816,7 @@ func (m *PushSpaceRequest) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.SpaceHeader == nil {
m.SpaceHeader = &SpaceHeader{}
m.SpaceHeader = &RawSpaceHeaderWithId{}
}
if err := m.SpaceHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
@ -3951,6 +4117,240 @@ func (m *SpaceHeader) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *RawSpaceHeader) 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 ErrIntOverflowSpacesync
}
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: RawSpaceHeader: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: RawSpaceHeader: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SpaceHeader", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSpacesync
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthSpacesync
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthSpacesync
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.SpaceHeader = append(m.SpaceHeader[:0], dAtA[iNdEx:postIndex]...)
if m.SpaceHeader == nil {
m.SpaceHeader = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSpacesync
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthSpacesync
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthSpacesync
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
if m.Signature == nil {
m.Signature = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSpacesync(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthSpacesync
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *RawSpaceHeaderWithId) 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 ErrIntOverflowSpacesync
}
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: RawSpaceHeaderWithId: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: RawSpaceHeaderWithId: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RawHeader", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSpacesync
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthSpacesync
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthSpacesync
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.RawHeader = append(m.RawHeader[:0], dAtA[iNdEx:postIndex]...)
if m.RawHeader == nil {
m.RawHeader = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSpacesync
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthSpacesync
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSpacesync
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Id = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSpacesync(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthSpacesync
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipSpacesync(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0

4
common/commonspace/storage/mock_storage/mock_storage.go
View File

@ -149,10 +149,10 @@ func (mr *MockSpaceStorageMockRecorder) CreateTreeStorage(arg0 interface{}) *gom
}
// SpaceHeader mocks base method.
func (m *MockSpaceStorage) SpaceHeader() (*spacesyncproto.SpaceHeader, error) {
func (m *MockSpaceStorage) SpaceHeader() (*spacesyncproto.RawSpaceHeaderWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SpaceHeader")
ret0, _ := ret[0].(*spacesyncproto.SpaceHeader)
ret0, _ := ret[0].(*spacesyncproto.RawSpaceHeaderWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}

7
common/commonspace/storage/storage.go
View File

@ -17,14 +17,13 @@ var ErrSpaceStorageMissing = errors.New("space storage missing")
type SpaceStorage interface {
storage.Provider
ACLStorage() (storage.ListStorage, error)
SpaceHeader() (*spacesyncproto.SpaceHeader, error)
SpaceHeader() (*spacesyncproto.RawSpaceHeaderWithId, error)
StoredIds() ([]string, error)
}
type SpaceStorageCreatePayload struct {
RecWithId *aclrecordproto.RawACLRecordWithId
SpaceHeader *spacesyncproto.SpaceHeader
Id string
RecWithId *aclrecordproto.RawACLRecordWithId
SpaceHeaderWithId *spacesyncproto.RawSpaceHeaderWithId
}
type SpaceStorageProvider interface {

7
node/nodespace/rpchandler.go
View File

@ -12,7 +12,7 @@ type rpcHandler struct {
}
func (r *rpcHandler) PushSpace(ctx context.Context, req *spacesyncproto.PushSpaceRequest) (resp *spacesyncproto.PushSpaceResponse, err error) {
_, err = r.s.GetSpace(ctx, req.SpaceId)
_, err = r.s.GetSpace(ctx, req.SpaceHeader.Id)
if err == nil {
err = spacesyncproto.ErrSpaceExists
return
@ -23,9 +23,8 @@ func (r *rpcHandler) PushSpace(ctx context.Context, req *spacesyncproto.PushSpac
}
payload := storage.SpaceStorageCreatePayload{
RecWithId: req.AclRoot,
SpaceHeader: req.SpaceHeader,
Id: req.SpaceId,
RecWithId: req.AclRoot,
SpaceHeaderWithId: req.SpaceHeader,
}
_, err = r.s.spaceStorageProvider.CreateSpaceStorage(payload)
if err != nil {

6
node/storage/keys.go
View File

@ -10,7 +10,7 @@ type treeKeys struct {
}
func (t treeKeys) HeadsKey() string {
return fmt.Sprintf("%s/heads", t.id)
return fmt.Sprintf("t/%s/heads", t.id)
}
func (t treeKeys) RootKey() string {
@ -18,7 +18,7 @@ func (t treeKeys) RootKey() string {
}
func (t treeKeys) RawChangeKey(id string) string {
return fmt.Sprintf("%s/%s", t.id, id)
return fmt.Sprintf("t/%s/%s", t.id, id)
}
type spaceKeys struct {
@ -33,5 +33,5 @@ func (s spaceKeys) ACLKey() string {
}
func isTreeKey(path string) bool {
return strings.HasPrefix(path, "t/")
return strings.HasPrefix(path, "t/") && len(strings.Split(path, "/")) > 2
}

21
node/storage/spacestorage.go
View File

@ -49,7 +49,8 @@ func newSpaceStorage(rootPath string, spaceId string) (store spacestorage.SpaceS
}
func createSpaceStorage(rootPath string, payload spacestorage.SpaceStorageCreatePayload) (store spacestorage.SpaceStorage, err error) {
dbPath := path.Join(rootPath, payload.Id)
// TODO: add payload verification
dbPath := path.Join(rootPath, payload.SpaceHeaderWithId.Id)
db, err := pogreb.Open(dbPath, nil)
if err != nil {
return
@ -65,19 +66,24 @@ func createSpaceStorage(rootPath string, payload spacestorage.SpaceStorageCreate
return
}
err = db.Put([]byte(payload.RecWithId.Id), payload.RecWithId.Payload)
marshalledRec, err := payload.RecWithId.Marshal()
if err != nil {
return
}
err = db.Put([]byte(keys.ACLKey()), marshalledRec)
if err != nil {
return
}
marshalled, err := payload.SpaceHeader.Marshal()
marshalledHeader, err := payload.SpaceHeaderWithId.Marshal()
if err != nil {
return
}
err = db.Put([]byte(payload.Id), marshalled)
err = db.Put([]byte(keys.HeaderKey()), marshalledHeader)
if err != nil {
return
}
store = &spaceStorage{
objDb: db,
keys: keys,
@ -100,6 +106,7 @@ func (s *spaceStorage) CreateTreeStorage(payload storage.TreeStorageCreatePayloa
err = spacestorage.ErrSpaceStorageExists
return
}
return createTreeStorage(s.objDb, payload)
}
@ -107,19 +114,20 @@ func (s *spaceStorage) ACLStorage() (storage.ListStorage, error) {
return nil, nil
}
func (s *spaceStorage) SpaceHeader() (header *spacesyncproto.SpaceHeader, err error) {
func (s *spaceStorage) SpaceHeader() (header *spacesyncproto.RawSpaceHeaderWithId, err error) {
res, err := s.objDb.Get([]byte(s.keys.HeaderKey()))
if err != nil {
return
}
header = &spacesyncproto.SpaceHeader{}
header = &spacesyncproto.RawSpaceHeaderWithId{}
err = proto.Unmarshal(res, header)
return
}
func (s *spaceStorage) StoredIds() (ids []string, err error) {
index := s.objDb.Items()
_, value, err := index.Next()
for err == nil {
strVal := string(value)
@ -128,6 +136,7 @@ func (s *spaceStorage) StoredIds() (ids []string, err error) {
}
_, value, err = index.Next()
}
if err != pogreb.ErrIterationDone {
return
}

37
node/storage/treestorage.go
View File

@ -28,11 +28,19 @@ func newTreeStorage(db *pogreb.DB, treeId string) (ts storage.TreeStorage, err e
if err != nil {
return
}
if heads == nil {
err = storage.ErrUnknownTreeId
return
}
res, err := db.Get([]byte(path.RootKey()))
if err != nil {
return
}
if res == nil {
err = storage.ErrUnknownTreeId
return
}
root := &treechangeproto.RawTreeChangeWithId{}
err = proto.Unmarshal(res, root)
@ -53,31 +61,46 @@ func newTreeStorage(db *pogreb.DB, treeId string) (ts storage.TreeStorage, err e
}
func createTreeStorage(db *pogreb.DB, payload storage.TreeStorageCreatePayload) (ts storage.TreeStorage, err error) {
path := treeKeys{payload.TreeId}
keys := treeKeys{id: payload.TreeId}
has, err := db.Has([]byte(keys.RootKey()))
if err != nil {
return
}
if !has {
err = storage.ErrUnknownTreeId
return
}
heads := createHeadsPayload(payload.Heads)
for _, ch := range payload.Changes {
err = db.Put([]byte(path.RawChangeKey(ch.Id)), ch.GetRawChange())
err = db.Put([]byte(keys.RawChangeKey(ch.Id)), ch.GetRawChange())
if err != nil {
return
}
}
err = db.Put([]byte(path.HeadsKey()), heads)
err = db.Put([]byte(keys.HeadsKey()), heads)
if err != nil {
return
}
err = db.Put([]byte(path.RootKey()), payload.RootRawChange.GetRawChange())
// duplicating same change in raw changes
err = db.Put([]byte(keys.RawChangeKey(payload.TreeId)), payload.RootRawChange.GetRawChange())
if err != nil {
return
}
err = db.Put([]byte(keys.RootKey()), payload.RootRawChange.GetRawChange())
if err != nil {
return
}
ts = &treeStorage{
db: db,
path: path,
rootPath: []byte(path.RootKey()),
headsPath: []byte(path.HeadsKey()),
path: keys,
rootPath: []byte(keys.RootKey()),
headsPath: []byte(keys.HeadsKey()),
id: payload.TreeId,
heads: payload.Heads,
root: payload.RootRawChange,

1
pkg/acl/aclrecordproto/aclrecord.pb.go
View File

@ -324,7 +324,6 @@ func (m *ACLRoot) GetTimestamp() int64 {
type ACLContentValue struct {
// Types that are valid to be assigned to Value:
//
// *ACLContentValue_UserAdd
// *ACLContentValue_UserRemove
// *ACLContentValue_UserPermissionChange

1
pkg/acl/testutils/testchanges/proto/test.pb.go
View File

@ -60,7 +60,6 @@ var xxx_messageInfo_PlainTextChange proto.InternalMessageInfo
type PlainTextChange_Content struct {
// Types that are valid to be assigned to Value:
//
// *PlainTextChange_Content_TextAppend
Value isPlainTextChange_Content_Value `protobuf_oneof:"value"`
}

4
pkg/acl/tree/mock_objecttree/mock_objecttree.go
View File

@ -137,7 +137,7 @@ func (mr *MockObjectTreeMockRecorder) HasChanges(arg0 ...interface{}) *gomock.Ca
// Header mocks base method.
func (m *MockObjectTree) Header() *treechangeproto.RawTreeChangeWithId {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HeaderKey")
ret := m.ctrl.Call(m, "Header")
ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
return ret0
}
@ -145,7 +145,7 @@ func (m *MockObjectTree) Header() *treechangeproto.RawTreeChangeWithId {
// Header indicates an expected call of Header.
func (mr *MockObjectTreeMockRecorder) Header() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderKey", reflect.TypeOf((*MockObjectTree)(nil).Header))
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockObjectTree)(nil).Header))
}
// Heads mocks base method.