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

Update sync handler

Browse Source
This commit is contained in:
mcrakhman 2022-09-16 10:17:54 +02:00 committed by Mikhail Iudin
parent ce2c2eaecc
commit 0e95dbfecf
No known key found for this signature in database
GPG Key ID: FAAAA8BAABDFF1C0
3 changed files with 247 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -51,6 +51,9 @@ message ObjectSyncMessage {
ObjectSyncContentValue content = 2; ObjectSyncContentValue content = 2;
acl.TreeHeader treeHeader = 3; acl.TreeHeader treeHeader = 3;
string treeId = 4; string treeId = 4;
string identity = 5;
string peerSignature = 6;
} }
// ObjectSyncContentValue provides different types for object sync // ObjectSyncContentValue provides different types for object sync
@ -72,7 +75,8 @@ message ObjectHeadUpdate {
// ObjectHeadUpdate is a message sent when document needs full sync // ObjectHeadUpdate is a message sent when document needs full sync
message ObjectFullSyncRequest { message ObjectFullSyncRequest {
repeated string heads = 1; repeated string heads = 1;
repeated string snapshotPath = 2; repeated acl.RawTreeChangeWithId changes = 2;
repeated string snapshotPath = 3;
} }
// ObjectFullSyncResponse is a message sent as a response for a specific full sync // ObjectFullSyncResponse is a message sent as a response for a specific full sync

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

@ -320,10 +320,12 @@ func (m *HeadSyncResponse) GetResults() []*HeadSyncResult {
// ObjectSyncMessage is a message sent on object sync // ObjectSyncMessage is a message sent on object sync
type ObjectSyncMessage struct { type ObjectSyncMessage struct {
SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"` SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
Content *ObjectSyncContentValue `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"` Content *ObjectSyncContentValue `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
TreeHeader *aclpb.TreeHeader `protobuf:"bytes,3,opt,name=treeHeader,proto3" json:"treeHeader,omitempty"` TreeHeader *aclpb.TreeHeader `protobuf:"bytes,3,opt,name=treeHeader,proto3" json:"treeHeader,omitempty"`
TreeId string `protobuf:"bytes,4,opt,name=treeId,proto3" json:"treeId,omitempty"` TreeId string `protobuf:"bytes,4,opt,name=treeId,proto3" json:"treeId,omitempty"`
Identity string `protobuf:"bytes,5,opt,name=identity,proto3" json:"identity,omitempty"`
PeerSignature string `protobuf:"bytes,6,opt,name=peerSignature,proto3" json:"peerSignature,omitempty"`
} }
func (m *ObjectSyncMessage) Reset() { *m = ObjectSyncMessage{} } func (m *ObjectSyncMessage) Reset() { *m = ObjectSyncMessage{} }
@ -387,6 +389,20 @@ func (m *ObjectSyncMessage) GetTreeId() string {
return "" return ""
} }
func (m *ObjectSyncMessage) GetIdentity() string {
if m != nil {
return m.Identity
}
return ""
}
func (m *ObjectSyncMessage) GetPeerSignature() string {
if m != nil {
return m.PeerSignature
}
return ""
}
// ObjectSyncContentValue provides different types for object sync // ObjectSyncContentValue provides different types for object sync
type ObjectSyncContentValue struct { type ObjectSyncContentValue struct {
// Types that are valid to be assigned to Value: // Types that are valid to be assigned to Value:
@ -549,8 +565,9 @@ func (m *ObjectHeadUpdate) GetSnapshotPath() []string {
// ObjectHeadUpdate is a message sent when document needs full sync // ObjectHeadUpdate is a message sent when document needs full sync
type ObjectFullSyncRequest struct { type ObjectFullSyncRequest struct {
Heads []string `protobuf:"bytes,1,rep,name=heads,proto3" json:"heads,omitempty"` Heads []string `protobuf:"bytes,1,rep,name=heads,proto3" json:"heads,omitempty"`
SnapshotPath []string `protobuf:"bytes,2,rep,name=snapshotPath,proto3" json:"snapshotPath,omitempty"` Changes []*aclpb.RawTreeChangeWithId `protobuf:"bytes,2,rep,name=changes,proto3" json:"changes,omitempty"`
SnapshotPath []string `protobuf:"bytes,3,rep,name=snapshotPath,proto3" json:"snapshotPath,omitempty"`
} }
func (m *ObjectFullSyncRequest) Reset() { *m = ObjectFullSyncRequest{} } func (m *ObjectFullSyncRequest) Reset() { *m = ObjectFullSyncRequest{} }
@ -593,6 +610,13 @@ func (m *ObjectFullSyncRequest) GetHeads() []string {
return nil return nil
} }
func (m *ObjectFullSyncRequest) GetChanges() []*aclpb.RawTreeChangeWithId {
if m != nil {
return m.Changes
}
return nil
}
func (m *ObjectFullSyncRequest) GetSnapshotPath() []string { func (m *ObjectFullSyncRequest) GetSnapshotPath() []string {
if m != nil { if m != nil {
return m.SnapshotPath return m.SnapshotPath
@ -680,49 +704,51 @@ func init() {
} }
var fileDescriptor_5855f4ef9cf24cdb = []byte{ var fileDescriptor_5855f4ef9cf24cdb = []byte{
// 666 bytes of a gzipped FileDescriptorProto // 695 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0x4f, 0x6f, 0xd3, 0x4e, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xcb, 0x6f, 0xd3, 0x4e,
0x10, 0xf5, 0xa6, 0x6d, 0x92, 0x4e, 0xfa, 0x27, 0xbf, 0xd5, 0xaf, 0xc5, 0x04, 0x29, 0x0d, 0x3e, 0x10, 0x8e, 0xd3, 0xe6, 0xd1, 0x49, 0x1f, 0xf9, 0xad, 0x7e, 0x2d, 0x26, 0x48, 0x69, 0xb0, 0x38,
0x45, 0x1c, 0x92, 0x2a, 0x5c, 0x10, 0xe5, 0x42, 0xab, 0x56, 0x89, 0x10, 0xff, 0xb6, 0x14, 0x24, 0x44, 0x1c, 0x92, 0x2a, 0x5c, 0x10, 0xe5, 0x42, 0xab, 0x56, 0x89, 0x10, 0x0f, 0x6d, 0x28, 0x48,
0xc4, 0x65, 0x6b, 0x4f, 0x9b, 0x80, 0x63, 0x1b, 0xef, 0x86, 0xd2, 0x1b, 0x27, 0xce, 0x88, 0x8f, 0x88, 0xcb, 0xd6, 0x9e, 0x26, 0x06, 0xc7, 0x36, 0xde, 0x0d, 0x25, 0x37, 0x2e, 0x70, 0x46, 0xfc,
0xc2, 0xa7, 0xe0, 0xd8, 0x23, 0x47, 0xd4, 0x7e, 0x0d, 0x0e, 0x68, 0xc7, 0x76, 0x92, 0x06, 0xb7, 0x55, 0x1c, 0x7b, 0xe4, 0x88, 0xda, 0x7f, 0x81, 0x23, 0x07, 0xb4, 0x63, 0x3b, 0x2f, 0xd2, 0x72,
0xdc, 0x38, 0xc4, 0xde, 0x99, 0x9d, 0xf7, 0xf6, 0xcd, 0x5b, 0x4f, 0xe0, 0x9e, 0x1b, 0x0e, 0x87, 0xeb, 0x21, 0xf6, 0xce, 0xec, 0xf7, 0xcd, 0x7e, 0x33, 0xb3, 0x13, 0xc3, 0x7d, 0x3b, 0x18, 0x0c,
0x61, 0xd0, 0x4e, 0x5e, 0x2a, 0x92, 0x2e, 0xb6, 0xe9, 0xa9, 0x4e, 0x03, 0x37, 0x8a, 0x43, 0x1d, 0x02, 0xbf, 0x19, 0xbf, 0x64, 0x28, 0x6c, 0x6c, 0xd2, 0x53, 0x8e, 0x7c, 0x3b, 0x8c, 0x02, 0x15,
0xb6, 0xe9, 0xa9, 0x26, 0xd9, 0x16, 0x25, 0x78, 0x59, 0x06, 0xa7, 0xfb, 0x26, 0x57, 0xdb, 0x8c, 0x34, 0xe9, 0x29, 0x27, 0xde, 0x06, 0x39, 0x58, 0x51, 0xf8, 0xa3, 0xae, 0xf6, 0x55, 0x76, 0xc2,
0xde, 0x1d, 0xb7, 0xa5, 0xeb, 0x9b, 0x9f, 0xdb, 0x97, 0xc1, 0x31, 0x2a, 0xb3, 0x8c, 0x0e, 0x33, 0x77, 0xbd, 0xa6, 0xb0, 0x3d, 0xfd, 0xb3, 0xfb, 0xc2, 0xef, 0xa1, 0xd4, 0xcb, 0xf0, 0x38, 0xa5,
0xe8, 0x24, 0x9f, 0x60, 0x9d, 0x1e, 0x2c, 0x77, 0x51, 0x7a, 0xfb, 0xa7, 0x81, 0x2b, 0x4c, 0x9e, 0x4e, 0xfc, 0x31, 0xd7, 0xea, 0xc0, 0x5a, 0x1b, 0x85, 0xd3, 0x1d, 0xf9, 0x36, 0xd7, 0x7e, 0xc6,
0x73, 0x98, 0x3f, 0x8a, 0xc3, 0xa1, 0xcd, 0x1a, 0xac, 0x39, 0x2f, 0x68, 0xcd, 0x57, 0xa0, 0xa0, 0x60, 0xf9, 0x24, 0x0a, 0x06, 0xa6, 0x51, 0x33, 0xea, 0xcb, 0x9c, 0xd6, 0x6c, 0x1d, 0xb2, 0x2a,
0x43, 0xbb, 0x40, 0x99, 0x82, 0x0e, 0xf9, 0xff, 0xb0, 0xe0, 0x0f, 0x86, 0x03, 0x6d, 0xcf, 0x35, 0x30, 0xb3, 0xe4, 0xc9, 0xaa, 0x80, 0xfd, 0x0f, 0x39, 0xcf, 0x1d, 0xb8, 0xca, 0x5c, 0xaa, 0x19,
0x58, 0x73, 0x59, 0x24, 0x81, 0x73, 0x02, 0x2b, 0x63, 0x2a, 0x54, 0x23, 0x5f, 0x1b, 0xae, 0xbe, 0xf5, 0x35, 0x1e, 0x1b, 0xd6, 0x29, 0xac, 0x8f, 0x43, 0xa1, 0x1c, 0x7a, 0x4a, 0xc7, 0xea, 0x0b,
0x54, 0x7d, 0xe2, 0x5a, 0x12, 0xb4, 0xe6, 0x5b, 0x50, 0x46, 0x1f, 0x87, 0x18, 0x68, 0x65, 0x17, 0xd9, 0xa7, 0x58, 0xab, 0x9c, 0xd6, 0x6c, 0x17, 0x8a, 0xe8, 0xe1, 0x00, 0x7d, 0x25, 0xcd, 0x6c,
0x1a, 0x73, 0xcd, 0x4a, 0x67, 0xa3, 0x95, 0xe9, 0x6f, 0x5d, 0xc6, 0xef, 0x26, 0x75, 0x62, 0x0c, 0x6d, 0xa9, 0x5e, 0x6a, 0x6d, 0x37, 0x52, 0xfd, 0x8d, 0x59, 0xfe, 0x41, 0x8c, 0xe3, 0x63, 0x82,
0x30, 0x07, 0xbb, 0xe1, 0x28, 0x18, 0x1f, 0x4c, 0x81, 0xb3, 0x05, 0x6b, 0xb9, 0x40, 0xa3, 0x7b, 0x3e, 0xd8, 0x0e, 0x86, 0xfe, 0xf8, 0x60, 0x32, 0xac, 0x5d, 0xd8, 0x5c, 0x48, 0xd4, 0xba, 0x5d,
0xe0, 0xd1, 0xe9, 0x8b, 0xa2, 0x30, 0xf0, 0x48, 0x0f, 0x4a, 0x8f, 0x3a, 0x59, 0x14, 0xb4, 0x76, 0x87, 0x4e, 0x5f, 0xe1, 0x59, 0xd7, 0x21, 0x3d, 0x28, 0x1c, 0xca, 0x64, 0x85, 0xd3, 0xda, 0x7a,
0xde, 0xc0, 0xea, 0x04, 0xfc, 0x7e, 0x84, 0x4a, 0x73, 0x1b, 0x4a, 0x64, 0x71, 0x2f, 0xc3, 0x66, 0x03, 0x1b, 0x13, 0xf2, 0xfb, 0x21, 0x4a, 0xc5, 0x4c, 0x28, 0x50, 0x89, 0x3b, 0x29, 0x37, 0x35,
0x21, 0x6f, 0x43, 0x31, 0x26, 0xf7, 0x52, 0xe9, 0x37, 0x72, 0xa4, 0x9b, 0x7d, 0x91, 0x96, 0x39, 0x59, 0x13, 0xf2, 0x11, 0x55, 0x2f, 0x91, 0x7e, 0x63, 0x81, 0x74, 0xbd, 0xcf, 0x13, 0x98, 0x75,
0x7b, 0x50, 0x9d, 0x92, 0x16, 0x85, 0x81, 0x42, 0xde, 0x81, 0x52, 0x4c, 0x32, 0x95, 0xcd, 0x88, 0x08, 0xe5, 0x29, 0x69, 0x61, 0xe0, 0x4b, 0x64, 0x2d, 0x28, 0x44, 0x24, 0x53, 0x9a, 0x06, 0x45,
0xc5, 0xbe, 0xca, 0x00, 0x91, 0x15, 0x3a, 0xdf, 0x18, 0xfc, 0xf7, 0xf4, 0xf0, 0x2d, 0xba, 0xda, 0x31, 0x2f, 0x2b, 0x00, 0x4f, 0x81, 0xd6, 0x2f, 0x03, 0xfe, 0x7b, 0x76, 0xfc, 0x16, 0x6d, 0xa5,
0xec, 0x3e, 0x46, 0xa5, 0xe4, 0x31, 0x5e, 0x23, 0xf4, 0x3e, 0x94, 0xdc, 0x30, 0xd0, 0x18, 0x68, 0x77, 0x9f, 0xa0, 0x94, 0xa2, 0x87, 0x57, 0x08, 0x7d, 0x00, 0x05, 0x3b, 0xf0, 0x15, 0xfa, 0x8a,
0x6a, 0xb6, 0xd2, 0x69, 0x4c, 0xce, 0x98, 0xf0, 0xec, 0x24, 0x25, 0x2f, 0xa5, 0x3f, 0x42, 0x91, 0x92, 0x2d, 0xb5, 0x6a, 0x93, 0x33, 0x26, 0x71, 0xf6, 0x63, 0xc8, 0x4b, 0xe1, 0x0d, 0x91, 0xa7,
0x01, 0x78, 0x1b, 0x40, 0xc7, 0x88, 0x46, 0x0a, 0xc6, 0xe4, 0x74, 0xa5, 0xb3, 0xda, 0x92, 0xae, 0x04, 0xd6, 0x04, 0x50, 0x11, 0xa2, 0x96, 0x82, 0x11, 0x55, 0xba, 0xd4, 0xda, 0x68, 0x08, 0xdb,
0xdf, 0x7a, 0x31, 0x4e, 0x8b, 0xa9, 0x12, 0xbe, 0x0e, 0x45, 0x13, 0xf5, 0x3c, 0x7b, 0x9e, 0x54, 0x6b, 0xbc, 0x18, 0xbb, 0xf9, 0x14, 0x84, 0x6d, 0x41, 0x5e, 0x5b, 0x1d, 0xc7, 0x5c, 0x26, 0x15,
0xa4, 0x91, 0xf3, 0x8b, 0xc1, 0x7a, 0xfe, 0x61, 0xfc, 0x01, 0x80, 0x71, 0xff, 0x20, 0xf2, 0xa4, 0x89, 0xc5, 0x2a, 0x50, 0x74, 0x1d, 0xf4, 0x95, 0xab, 0x46, 0x66, 0x8e, 0x76, 0xc6, 0x36, 0xbb,
0x46, 0x12, 0x5f, 0xe9, 0xd4, 0x66, 0x25, 0x76, 0xc7, 0x15, 0x5d, 0x4b, 0x4c, 0xd5, 0xf3, 0x47, 0x03, 0x6b, 0x21, 0x62, 0xd4, 0x75, 0x7b, 0xbe, 0x50, 0xc3, 0x08, 0xcd, 0x3c, 0x01, 0x66, 0x9d,
0xb0, 0x7a, 0x34, 0xf2, 0xfd, 0xa9, 0x3b, 0x4b, 0xbb, 0xdc, 0x98, 0xa5, 0xd8, 0xbb, 0x5c, 0xd6, 0xd6, 0x6f, 0x03, 0xb6, 0x16, 0xcb, 0x65, 0x0f, 0x01, 0x74, 0xff, 0x8e, 0x42, 0x47, 0x28, 0xa4,
0xb5, 0xc4, 0x2c, 0x92, 0x3f, 0x81, 0xea, 0x24, 0x95, 0x5c, 0x51, 0xda, 0x74, 0xe3, 0x6a, 0xb6, 0xf4, 0x4b, 0xad, 0xca, 0x7c, 0x92, 0xed, 0x31, 0xa2, 0x9d, 0xe1, 0x53, 0x78, 0xf6, 0x18, 0x36,
0xa4, 0xae, 0x6b, 0x89, 0x3f, 0xb0, 0xdb, 0x25, 0x58, 0xf8, 0x60, 0x7a, 0x74, 0x3e, 0x31, 0xa8, 0x4e, 0x86, 0x9e, 0x37, 0xd5, 0xf5, 0xa4, 0x4e, 0xdb, 0xf3, 0x21, 0x0e, 0x67, 0x61, 0xed, 0x0c,
0xce, 0x36, 0x62, 0xbe, 0x60, 0xd3, 0x48, 0x72, 0xf5, 0x8b, 0x22, 0x09, 0xcc, 0x27, 0x91, 0x8e, 0x9f, 0x67, 0xb2, 0xa7, 0x50, 0x9e, 0xb8, 0xe2, 0x26, 0x27, 0x65, 0xab, 0x5d, 0x1e, 0x2d, 0xc6,
0x65, 0xfa, 0x61, 0xd9, 0xe4, 0xb7, 0x90, 0x27, 0xc6, 0xf2, 0x1d, 0xda, 0x7a, 0x35, 0xd0, 0xfd, 0xb5, 0x33, 0xfc, 0x2f, 0xee, 0x5e, 0x01, 0x72, 0x1f, 0x74, 0x8e, 0xd6, 0x27, 0x03, 0xca, 0xf3,
0x9e, 0x27, 0xb2, 0x42, 0xee, 0xc0, 0x92, 0x0a, 0x64, 0xa4, 0xfa, 0xa1, 0x7e, 0x26, 0x75, 0xdf, 0x89, 0xe8, 0x19, 0xd0, 0x89, 0xc4, 0x97, 0x67, 0x85, 0xc7, 0x86, 0xbe, 0x54, 0xc9, 0x60, 0x27,
0x9e, 0x23, 0xc2, 0x4b, 0x39, 0xe7, 0x39, 0xac, 0xe5, 0xfa, 0x70, 0x85, 0x8c, 0x59, 0xca, 0x42, 0x57, 0xd3, 0xa4, 0x8e, 0x71, 0x71, 0xaa, 0x9b, 0xb6, 0x4f, 0x5b, 0xaf, 0x5c, 0xd5, 0xef, 0x38,
0x0e, 0xe5, 0xe7, 0xf1, 0xa5, 0xce, 0xba, 0xf1, 0x6f, 0x7b, 0xbb, 0x53, 0x83, 0xf2, 0x6e, 0x1c, 0x3c, 0x05, 0x32, 0x0b, 0x56, 0xa5, 0x2f, 0x42, 0xd9, 0x0f, 0xd4, 0x73, 0xa1, 0xfa, 0xe6, 0x12,
0xef, 0x84, 0x1e, 0x2a, 0xbe, 0x02, 0x70, 0x10, 0xe0, 0xc7, 0x08, 0x5d, 0x8d, 0x5e, 0xd5, 0xea, 0x05, 0x9c, 0xf1, 0x59, 0x9f, 0x0d, 0xd8, 0x5c, 0x58, 0x88, 0x6b, 0xd6, 0xf1, 0x65, 0x7c, 0x13,
0x7c, 0x65, 0xb0, 0x40, 0x17, 0xc7, 0x1f, 0x42, 0x39, 0x9b, 0x29, 0x7e, 0x33, 0x6f, 0xce, 0xc8, 0xe6, 0x4b, 0x78, 0xbd, 0x42, 0xee, 0x56, 0xa0, 0x78, 0x10, 0x45, 0xfb, 0x81, 0x83, 0x92, 0xad,
0x8f, 0x5a, 0x2d, 0x77, 0x04, 0x93, 0xb6, 0xf6, 0xa0, 0xb8, 0xaf, 0x63, 0x94, 0x43, 0x7e, 0x2b, 0x03, 0x1c, 0xf9, 0xf8, 0x31, 0x44, 0x5b, 0xa1, 0x53, 0xce, 0xb4, 0xbe, 0x19, 0x90, 0xa3, 0x6e,
0x6f, 0x88, 0xd2, 0x61, 0xac, 0x5d, 0xb7, 0xd9, 0x64, 0x9b, 0x6c, 0x7b, 0xeb, 0xfb, 0x79, 0x9d, 0xb3, 0x47, 0x50, 0x4c, 0x47, 0x99, 0xdd, 0x5c, 0x34, 0xde, 0x54, 0xc3, 0x4a, 0x65, 0xe1, 0xe4,
0x9d, 0x9d, 0xd7, 0xd9, 0xcf, 0xf3, 0x3a, 0xfb, 0x72, 0x51, 0xb7, 0xce, 0x2e, 0xea, 0xd6, 0x8f, 0xc7, 0x69, 0x1d, 0x42, 0xbe, 0xab, 0x22, 0x14, 0x03, 0x76, 0x6b, 0xd1, 0xec, 0x26, 0xff, 0x01,
0x8b, 0xba, 0xf5, 0xfa, 0xf6, 0x5f, 0xff, 0xfa, 0x0f, 0x8b, 0xf4, 0xba, 0xfb, 0x3b, 0x00, 0x00, 0x95, 0xab, 0x36, 0xeb, 0xc6, 0x8e, 0xb1, 0xb7, 0xfb, 0xfd, 0xbc, 0x6a, 0x9c, 0x9d, 0x57, 0x8d,
0xff, 0xff, 0xcf, 0x4f, 0x53, 0x3d, 0x26, 0x06, 0x00, 0x00, 0x9f, 0xe7, 0x55, 0xe3, 0xeb, 0x45, 0x35, 0x73, 0x76, 0x51, 0xcd, 0xfc, 0xb8, 0xa8, 0x66, 0x5e,
0xdf, 0xfe, 0xe7, 0x17, 0xe7, 0x38, 0x4f, 0xaf, 0x7b, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x57,
0xb9, 0x93, 0x47, 0x9d, 0x06, 0x00, 0x00,
} }
func (m *HeadSyncRange) Marshal() (dAtA []byte, err error) { func (m *HeadSyncRange) Marshal() (dAtA []byte, err error) {
@ -950,6 +976,20 @@ func (m *ObjectSyncMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if len(m.PeerSignature) > 0 {
i -= len(m.PeerSignature)
copy(dAtA[i:], m.PeerSignature)
i = encodeVarintSpacesync(dAtA, i, uint64(len(m.PeerSignature)))
i--
dAtA[i] = 0x32
}
if len(m.Identity) > 0 {
i -= len(m.Identity)
copy(dAtA[i:], m.Identity)
i = encodeVarintSpacesync(dAtA, i, uint64(len(m.Identity)))
i--
dAtA[i] = 0x2a
}
if len(m.TreeId) > 0 { if len(m.TreeId) > 0 {
i -= len(m.TreeId) i -= len(m.TreeId)
copy(dAtA[i:], m.TreeId) copy(dAtA[i:], m.TreeId)
@ -1167,6 +1207,20 @@ func (m *ObjectFullSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
copy(dAtA[i:], m.SnapshotPath[iNdEx]) copy(dAtA[i:], m.SnapshotPath[iNdEx])
i = encodeVarintSpacesync(dAtA, i, uint64(len(m.SnapshotPath[iNdEx]))) i = encodeVarintSpacesync(dAtA, i, uint64(len(m.SnapshotPath[iNdEx])))
i-- i--
dAtA[i] = 0x1a
}
}
if len(m.Changes) > 0 {
for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintSpacesync(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12 dAtA[i] = 0x12
} }
} }
@ -1361,6 +1415,14 @@ func (m *ObjectSyncMessage) Size() (n int) {
if l > 0 { if l > 0 {
n += 1 + l + sovSpacesync(uint64(l)) n += 1 + l + sovSpacesync(uint64(l))
} }
l = len(m.Identity)
if l > 0 {
n += 1 + l + sovSpacesync(uint64(l))
}
l = len(m.PeerSignature)
if l > 0 {
n += 1 + l + sovSpacesync(uint64(l))
}
return n return n
} }
@ -1451,6 +1513,12 @@ func (m *ObjectFullSyncRequest) Size() (n int) {
n += 1 + l + sovSpacesync(uint64(l)) n += 1 + l + sovSpacesync(uint64(l))
} }
} }
if len(m.Changes) > 0 {
for _, e := range m.Changes {
l = e.Size()
n += 1 + l + sovSpacesync(uint64(l))
}
}
if len(m.SnapshotPath) > 0 { if len(m.SnapshotPath) > 0 {
for _, s := range m.SnapshotPath { for _, s := range m.SnapshotPath {
l = len(s) l = len(s)
@ -2216,6 +2284,70 @@ func (m *ObjectSyncMessage) Unmarshal(dAtA []byte) error {
} }
m.TreeId = string(dAtA[iNdEx:postIndex]) m.TreeId = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Identity", 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.Identity = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PeerSignature", 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.PeerSignature = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
skippy, err := skipSpacesync(dAtA[iNdEx:]) skippy, err := skipSpacesync(dAtA[iNdEx:])
@ -2602,6 +2734,40 @@ func (m *ObjectFullSyncRequest) Unmarshal(dAtA []byte) error {
m.Heads = append(m.Heads, string(dAtA[iNdEx:postIndex])) m.Heads = append(m.Heads, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex iNdEx = postIndex
case 2: case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSpacesync
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthSpacesync
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthSpacesync
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Changes = append(m.Changes, &aclpb.RawTreeChangeWithId{})
if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 { if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SnapshotPath", wireType) return fmt.Errorf("proto: wrong wireType = %d for field SnapshotPath", wireType)
} }

77
common/commonspace/syncservice/synchandler.go
View File

@ -5,7 +5,6 @@ import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/cache" "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/cache"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto" "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb" "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/tree" "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/tree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/slice" "github.com/anytypeio/go-anytype-infrastructure-experiments/util/slice"
) )
@ -49,8 +48,6 @@ func (s *syncHandler) HandleHeadUpdate(
var ( var (
fullRequest *spacesyncproto.ObjectFullSyncRequest fullRequest *spacesyncproto.ObjectFullSyncRequest
result tree.AddResult result tree.AddResult
// in case update changes are empty then we want to sync the whole tree
sendChangesOnFullSync = len(update.Changes) == 0
) )
res, err := s.treeCache.GetTree(ctx, treeId) res, err := s.treeCache.GetTree(ctx, treeId)
@ -74,9 +71,8 @@ func (s *syncHandler) HandleHeadUpdate(
} }
// if we couldn't add all the changes // if we couldn't add all the changes
shouldFullSync := len(update.Changes) != len(result.Added) if len(update.Changes) != len(result.Added) {
if shouldFullSync { fullRequest, err = s.prepareFullSyncRequest(objTree, update)
fullRequest, err = s.prepareFullSyncRequest(objTree, sendChangesOnFullSync)
if err != nil { if err != nil {
return err return err
} }
@ -84,11 +80,6 @@ func (s *syncHandler) HandleHeadUpdate(
return nil return nil
}() }()
// if there are no such tree
if err == storage.ErrUnknownTreeId {
fullRequest = &spacesyncproto.ObjectFullSyncRequest{}
}
// if we have incompatible heads, or we haven't seen the tree at all
if fullRequest != nil { if fullRequest != nil {
return s.syncClient.SendAsync(senderId, spacesyncproto.WrapFullRequest(fullRequest, header, treeId)) return s.syncClient.SendAsync(senderId, spacesyncproto.WrapFullRequest(fullRequest, header, treeId))
} }
@ -109,21 +100,23 @@ func (s *syncHandler) HandleFullSyncRequest(
return return
} }
// TODO: check if sync request contains changes and add them (also do head update in this case)
err = func() error { err = func() error {
objTree := res.TreeContainer.Tree() objTree := res.TreeContainer.Tree()
objTree.Lock() objTree.Lock()
defer res.Release() defer res.Release()
defer objTree.Unlock() defer objTree.Unlock()
fullResponse, err = s.prepareFullSyncResponse(treeId, request.SnapshotPath, request.Heads, objTree)
_, err = objTree.AddRawChanges(ctx, request.Changes...)
if err != nil { if err != nil {
return err return err
} }
return nil
fullResponse, err = s.prepareFullSyncResponse(treeId, request.SnapshotPath, request.Heads, objTree)
return err
}() }()
if err != nil { if err != nil {
return err return
} }
return s.syncClient.SendAsync(senderId, spacesyncproto.WrapFullResponse(fullResponse, header, treeId)) return s.syncClient.SendAsync(senderId, spacesyncproto.WrapFullResponse(fullResponse, header, treeId))
} }
@ -135,8 +128,6 @@ func (s *syncHandler) HandleFullSyncResponse(
header *aclpb.TreeHeader, header *aclpb.TreeHeader,
treeId string) (err error) { treeId string) (err error) {
var result tree.AddResult
res, err := s.treeCache.GetTree(ctx, treeId) res, err := s.treeCache.GetTree(ctx, treeId)
if err != nil { if err != nil {
return return
@ -153,27 +144,28 @@ func (s *syncHandler) HandleFullSyncResponse(
return nil return nil
} }
result, err = objTree.AddRawChanges(ctx, response.Changes...) _, err = objTree.AddRawChanges(ctx, response.Changes...)
return err
if err != nil {
return err
}
return nil
}() }()
// if error or nothing has changed
if (err != nil || len(result.Added) == 0) && err != storage.ErrUnknownTreeId {
return err
}
// if we have a new tree
if err == storage.ErrUnknownTreeId {
return s.addTree(ctx, response, header, treeId)
}
return return
} }
func (s *syncHandler) prepareFullSyncRequest(t tree.ObjectTree, sendOwnChanges bool) (*spacesyncproto.ObjectFullSyncRequest, error) { func (s *syncHandler) prepareFullSyncRequest(
// TODO: add send own changes logic t tree.ObjectTree,
update *spacesyncproto.ObjectHeadUpdate) (req *spacesyncproto.ObjectFullSyncRequest, err error) {
req = &spacesyncproto.ObjectFullSyncRequest{
Heads: t.Heads(),
SnapshotPath: t.SnapshotPath(),
}
if len(update.Changes) != 0 {
var changesAfterSnapshot []*aclpb.RawTreeChangeWithId
changesAfterSnapshot, err = t.ChangesAfterCommonSnapshot(update.SnapshotPath, update.Heads)
if err != nil {
return
}
req.Changes = changesAfterSnapshot
}
return &spacesyncproto.ObjectFullSyncRequest{ return &spacesyncproto.ObjectFullSyncRequest{
Heads: t.Heads(), Heads: t.Heads(),
SnapshotPath: t.SnapshotPath(), SnapshotPath: t.SnapshotPath(),
@ -182,7 +174,8 @@ func (s *syncHandler) prepareFullSyncRequest(t tree.ObjectTree, sendOwnChanges b
func (s *syncHandler) prepareFullSyncResponse( func (s *syncHandler) prepareFullSyncResponse(
treeId string, treeId string,
theirPath, theirHeads []string, theirPath,
theirHeads []string,
t tree.ObjectTree) (*spacesyncproto.ObjectFullSyncResponse, error) { t tree.ObjectTree) (*spacesyncproto.ObjectFullSyncResponse, error) {
ourChanges, err := t.ChangesAfterCommonSnapshot(theirPath, theirHeads) ourChanges, err := t.ChangesAfterCommonSnapshot(theirPath, theirHeads)
if err != nil { if err != nil {
@ -195,19 +188,3 @@ func (s *syncHandler) prepareFullSyncResponse(
SnapshotPath: t.SnapshotPath(), SnapshotPath: t.SnapshotPath(),
}, nil }, nil
} }
func (s *syncHandler) addTree(
ctx context.Context,
response *spacesyncproto.ObjectFullSyncResponse,
header *aclpb.TreeHeader,
treeId string) error {
return s.treeCache.AddTree(
ctx,
storage.TreeStorageCreatePayload{
TreeId: treeId,
Header: header,
Changes: response.Changes,
Heads: response.Heads,
})
}