anyproto/any-sync
1
0
Fork 0
mirror of https://github.com/anyproto/any-sync.git synced 2025-06-08 05:57:03 +09:00
Code Activity

Benchmarks and snappy

Browse source
This commit is contained in:
Mikhail Rakhmanov 2025-03-31 22:05:52 +02:00
parent 1ddab840d9
commit 875ca9c48a
No known key found for this signature in database
GPG key ID: DED12CFEF5B8396B
11 changed files with 482 additions and 140 deletions
Download patch file Download diff file Expand all files Collapse all files

1
app/ldiff/diff.go
View file

@ -331,6 +331,7 @@ func (d *diff) compareResults(dctx *diffCtx, r Range, myRes, otherRes RangeResul
return
}
if otherRes.Count <= d.compareThreshold && len(otherRes.Elements) == 0 || len(myRes.Elements) == myRes.Count {
//fmt.Println(otherRes.Count, len(myRes.Elements), myRes.Count)
r.Elements = true
dctx.prepare = append(dctx.prepare, r)
return

15
app/ldiff/mock_ldiff/mock_ldiff.go
View file

@ -13,6 +13,7 @@ import (
reflect "reflect"
ldiff "github.com/anyproto/any-sync/app/ldiff"
spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
gomock "go.uber.org/mock/gomock"
)
@ -56,6 +57,20 @@ func (mr *MockDiffMockRecorder) Diff(arg0, arg1 any) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Diff", reflect.TypeOf((*MockDiff)(nil).Diff), arg0, arg1)
}
// DiffType mocks base method.
func (m *MockDiff) DiffType() spacesyncproto.DiffType {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DiffType")
ret0, _ := ret[0].(spacesyncproto.DiffType)
return ret0
}
// DiffType indicates an expected call of DiffType.
func (mr *MockDiffMockRecorder) DiffType() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DiffType", reflect.TypeOf((*MockDiff)(nil).DiffType))
}
// Element mocks base method.
func (m *MockDiff) Element(arg0 string) (ldiff.Element, error) {
m.ctrl.T.Helper()

1
app/olddiff/diff.go
View file

@ -1,4 +1,3 @@
//go:generate mockgen -destination mock_olddiff/mock_olddiff.go github.com/anyproto/any-sync/app/olddiff Diff,Remote
package olddiff
import (

4
commonspace/headsync/diffsyncer_test.go
View file

@ -135,7 +135,7 @@ func TestDiffSyncer(t *testing.T) {
deletedId := "id"
fx.diffMock.EXPECT().RemoveId(deletedId).Return(nil)
fx.diffMock.EXPECT().Hash().Return("hash")
fx.stateStorage.EXPECT().SetHash(gomock.Any(), "hash").Return(nil)
//fx.stateStorage.EXPECT().SetHash(gomock.Any(), "hash").Return(nil)
upd := headstorage.DeletedStatusDeleted
fx.diffSyncer.updateHeads(headstorage.HeadsUpdate{
Id: "id",
@ -154,7 +154,7 @@ func TestDiffSyncer(t *testing.T) {
Id: updatedId,
Head: "head",
})
fx.stateStorage.EXPECT().SetHash(gomock.Any(), "hash").Return(nil)
//fx.stateStorage.EXPECT().SetHash(gomock.Any(), "hash").Return(nil)
fx.diffSyncer.updateHeads(headstorage.HeadsUpdate{
Id: "id",
Heads: []string{"head"},

6
commonspace/headsync/headsync_test.go
View file

@ -144,7 +144,7 @@ func (fx *headSyncFixture) init(t *testing.T) {
fx.headStorage.EXPECT().AddObserver(gomock.Any())
err := fx.headSync.Init(fx.app)
require.NoError(t, err)
fx.headSync.diff = fx.diffMock
//fx.headSync.diff = fx.diffMock
}
func (fx *headSyncFixture) stop() {
@ -194,7 +194,7 @@ func TestHeadSync(t *testing.T) {
Head: "headId",
})
fx.diffMock.EXPECT().Hash().Return("hash")
fx.stateStorage.EXPECT().SetHash(gomock.Any(), "hash").Return(nil)
//fx.stateStorage.EXPECT().SetHash(gomock.Any(), "hash").Return(nil)
fx.diffSyncerMock.EXPECT().Sync(gomock.Any()).Return(nil)
fx.diffSyncerMock.EXPECT().Close()
err := fx.headSync.Run(ctx)
@ -240,7 +240,7 @@ func TestHeadSync(t *testing.T) {
Head: "headId",
})
fx.diffMock.EXPECT().Hash().Return("hash")
fx.stateStorage.EXPECT().SetHash(gomock.Any(), "hash").Return(nil)
//fx.stateStorage.EXPECT().SetHash(gomock.Any(), "hash").Return(nil)
fx.diffSyncerMock.EXPECT().Sync(gomock.Any()).Return(nil)
fx.diffSyncerMock.EXPECT().Close()
err := fx.headSync.Run(ctx)

34
commonspace/headsync/remotediff.go
View file

@ -6,6 +6,8 @@ import (
"encoding/hex"
"math"
"github.com/golang/snappy"
"github.com/anyproto/any-sync/app/ldiff"
"github.com/anyproto/any-sync/commonspace/spacesyncproto"
)
@ -52,6 +54,17 @@ func (r *remote) Ranges(ctx context.Context, ranges []ldiff.Range, resBuf []ldif
if err != nil {
return
}
if resp.EncodedResult != nil {
encoded := &spacesyncproto.EncodedHeadSyncResults{}
decodedBytes, err := snappy.Decode(nil, resp.EncodedResult)
if err != nil {
return nil, err
}
if err = encoded.Unmarshal(decodedBytes); err != nil {
return nil, err
}
resp.Results = encoded.Results
}
for _, rr := range resp.Results {
var elms []ldiff.Element
if len(rr.Elements) > 0 {
@ -82,6 +95,17 @@ func (r *remote) DiffTypeCheck(ctx context.Context, diffContainer ldiff.DiffCont
if err != nil {
return
}
if resp.EncodedResult != nil {
encoded := &spacesyncproto.EncodedHeadSyncResults{}
decodedBytes, err := snappy.Decode(nil, resp.EncodedResult)
if err != nil {
return false, nil, err
}
if err = encoded.Unmarshal(decodedBytes); err != nil {
return false, nil, err
}
resp.Results = encoded.Results
}
needsSync = true
checkHash := func(diff ldiff.Diff) (bool, error) {
hashB, err := hex.DecodeString(diff.Hash())
@ -141,6 +165,16 @@ func HandleRangeRequest(ctx context.Context, d ldiff.Diff, req *spacesyncproto.H
Count: uint32(rangeRes.Count),
})
}
if d.DiffType() == spacesyncproto.DiffType_V2 {
encoded := spacesyncproto.EncodedHeadSyncResults{Results: resp.Results}
resp.Results = nil
encodedBytes, err := encoded.Marshal()
if err != nil {
return nil, err
}
encodedBytes = snappy.Encode(nil, encodedBytes)
resp.EncodedResult = encodedBytes
}
resp.DiffType = d.DiffType()
return
}

98
commonspace/headsync/remotediff_test.go
View file

@ -2,6 +2,7 @@ package headsync
import (
"context"
"crypto/rand"
"fmt"
"testing"
@ -12,43 +13,84 @@ import (
"github.com/anyproto/any-sync/commonspace/spacesyncproto"
)
func TestRemote(t *testing.T) {
contLocal := ldiff.New(32, 256)
contRemote := ldiff.New(32, 256)
func benchmarkDifferentDiffs(t *testing.T, diffFactory func() ldiff.Diff, headLength int) {
moduloValues := []int{1, 10, 100, 1000, 10000, 100000}
totalElements := 1000000
test := func(t *testing.T, ldLocal, ldRemote ldiff.Diff) {
var (
localEls []ldiff.Element
remoteEls []ldiff.Element
)
for _, modVal := range moduloValues {
t.Run(fmt.Sprintf("New_%d", totalElements/modVal), func(t *testing.T) {
// Create a new diff instance for each test using the factory
contLocal := diffFactory()
contRemote := diffFactory()
remClient := &mockClient{t: t, l: contRemote}
for i := 0; i < 100000; i++ {
el := ldiff.Element{
Id: fmt.Sprint(i),
Head: fmt.Sprint(i),
var (
localEls []ldiff.Element
remoteEls []ldiff.Element
)
buf := make([]byte, headLength)
_, _ = rand.Read(buf)
for i := 0; i < totalElements; i++ {
el := ldiff.Element{
Id: fmt.Sprint(i),
Head: string(buf),
}
remoteEls = append(remoteEls, el)
if i%modVal != 0 {
localEls = append(localEls, el)
}
}
remoteEls = append(remoteEls, el)
if i%100 == 0 {
localEls = append(localEls, el)
}
}
ldLocal.Set(localEls...)
ldRemote.Set(remoteEls...)
rd := NewRemoteDiff("1", &mockClient{l: ldRemote})
newIds, changedIds, removedIds, err := ldLocal.Diff(context.Background(), rd)
require.NoError(t, err)
assert.Len(t, newIds, 99000)
assert.Len(t, changedIds, 0)
assert.Len(t, removedIds, 0)
contLocal.Set(localEls...)
remClient.l.Set(remoteEls...)
rd := NewRemoteDiff("1", remClient)
newIds, changedIds, removedIds, err := contLocal.Diff(context.Background(), rd)
require.NoError(t, err)
expectedNewCount := totalElements / modVal
assert.Len(t, newIds, expectedNewCount)
assert.Len(t, changedIds, 0)
assert.Len(t, removedIds, 0)
fmt.Printf("New count %d: total bytes sent: %d, %d\n", expectedNewCount, remClient.totalInSent, remClient.totalOutSent)
})
}
test(t, contLocal, contRemote)
}
func TestBenchRemoteWithDifferentCounts(t *testing.T) {
t.Run("StandardLdiff", func(t *testing.T) {
benchmarkDifferentDiffs(t, func() ldiff.Diff {
return ldiff.New(32, 256)
}, 32)
})
// old has higher head lengths because of hashes
//t.Run("OldLdiff", func(t *testing.T) {
// benchmarkDifferentDiffs(t, func() ldiff.Diff {
// return olddiff.New(32, 256)
// }, 100)
//})
}
type mockClient struct {
l ldiff.Diff
l ldiff.Diff
totalInSent int
totalOutSent int
t *testing.T
}
func (m *mockClient) HeadSync(ctx context.Context, in *spacesyncproto.HeadSyncRequest) (*spacesyncproto.HeadSyncResponse, error) {
return HandleRangeRequest(ctx, m.l, in)
res, err := in.Marshal()
require.NoError(m.t, err)
m.totalInSent += len(res)
resp, err := HandleRangeRequest(ctx, m.l, in)
if err != nil {
return nil, err
}
marsh, err := resp.Marshal()
require.NoError(m.t, err)
m.totalOutSent += len(marsh)
return resp, nil
}

5
commonspace/spacesyncproto/protos/spacesync.proto
View file

@ -59,6 +59,10 @@ message HeadSyncResultElement {
string head = 2;
}
message EncodedHeadSyncResults {
repeated HeadSyncResult results = 1;
}
// HeadSyncRequest is a request for HeadSync
message HeadSyncRequest {
string spaceId = 1;
@ -70,6 +74,7 @@ message HeadSyncRequest {
message HeadSyncResponse {
repeated HeadSyncResult results = 1;
DiffType diffType = 2;
bytes encodedResult = 3;
}
// ObjectSyncMessage is a message sent on object sync

455
commonspace/spacesyncproto/spacesync.pb.go
View file

@ -336,6 +336,58 @@ func (m *HeadSyncResultElement) GetHead() string {
return ""
}
type EncodedHeadSyncResults struct {
Results []*HeadSyncResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
}
func (m *EncodedHeadSyncResults) Reset() { *m = EncodedHeadSyncResults{} }
func (m *EncodedHeadSyncResults) String() string { return proto.CompactTextString(m) }
func (*EncodedHeadSyncResults) ProtoMessage() {}
func (*EncodedHeadSyncResults) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{3}
}
func (m *EncodedHeadSyncResults) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *EncodedHeadSyncResults) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_EncodedHeadSyncResults.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 *EncodedHeadSyncResults) XXX_MarshalAppend(b []byte, newLen int) ([]byte, error) {
b = b[:newLen]
_, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b, nil
}
func (m *EncodedHeadSyncResults) XXX_Merge(src proto.Message) {
xxx_messageInfo_EncodedHeadSyncResults.Merge(m, src)
}
func (m *EncodedHeadSyncResults) XXX_Size() int {
return m.Size()
}
func (m *EncodedHeadSyncResults) XXX_DiscardUnknown() {
xxx_messageInfo_EncodedHeadSyncResults.DiscardUnknown(m)
}
var xxx_messageInfo_EncodedHeadSyncResults proto.InternalMessageInfo
func (m *EncodedHeadSyncResults) GetResults() []*HeadSyncResult {
if m != nil {
return m.Results
}
return nil
}
// HeadSyncRequest is a request for HeadSync
type HeadSyncRequest struct {
SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
@ -347,7 +399,7 @@ func (m *HeadSyncRequest) Reset() { *m = HeadSyncRequest{} }
func (m *HeadSyncRequest) String() string { return proto.CompactTextString(m) }
func (*HeadSyncRequest) ProtoMessage() {}
func (*HeadSyncRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{3}
return fileDescriptor_80e49f1f4ac27799, []int{4}
}
func (m *HeadSyncRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -407,15 +459,16 @@ func (m *HeadSyncRequest) GetDiffType() DiffType {
// HeadSyncResponse is a response for HeadSync
type HeadSyncResponse struct {
Results []*HeadSyncResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
DiffType DiffType `protobuf:"varint,2,opt,name=diffType,proto3,enum=spacesync.DiffType" json:"diffType,omitempty"`
Results []*HeadSyncResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
DiffType DiffType `protobuf:"varint,2,opt,name=diffType,proto3,enum=spacesync.DiffType" json:"diffType,omitempty"`
EncodedResult []byte `protobuf:"bytes,3,opt,name=encodedResult,proto3" json:"encodedResult,omitempty"`
}
func (m *HeadSyncResponse) Reset() { *m = HeadSyncResponse{} }
func (m *HeadSyncResponse) String() string { return proto.CompactTextString(m) }
func (*HeadSyncResponse) ProtoMessage() {}
func (*HeadSyncResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{4}
return fileDescriptor_80e49f1f4ac27799, []int{5}
}
func (m *HeadSyncResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -466,6 +519,13 @@ func (m *HeadSyncResponse) GetDiffType() DiffType {
return DiffType_Initial
}
func (m *HeadSyncResponse) GetEncodedResult() []byte {
if m != nil {
return m.EncodedResult
}
return nil
}
// ObjectSyncMessage is a message sent on object sync
type ObjectSyncMessage struct {
SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
@ -479,7 +539,7 @@ func (m *ObjectSyncMessage) Reset() { *m = ObjectSyncMessage{} }
func (m *ObjectSyncMessage) String() string { return proto.CompactTextString(m) }
func (*ObjectSyncMessage) ProtoMessage() {}
func (*ObjectSyncMessage) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{5}
return fileDescriptor_80e49f1f4ac27799, []int{6}
}
func (m *ObjectSyncMessage) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -561,7 +621,7 @@ func (m *SpacePushRequest) Reset() { *m = SpacePushRequest{} }
func (m *SpacePushRequest) String() string { return proto.CompactTextString(m) }
func (*SpacePushRequest) ProtoMessage() {}
func (*SpacePushRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{6}
return fileDescriptor_80e49f1f4ac27799, []int{7}
}
func (m *SpacePushRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -620,7 +680,7 @@ func (m *SpacePushResponse) Reset() { *m = SpacePushResponse{} }
func (m *SpacePushResponse) String() string { return proto.CompactTextString(m) }
func (*SpacePushResponse) ProtoMessage() {}
func (*SpacePushResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{7}
return fileDescriptor_80e49f1f4ac27799, []int{8}
}
func (m *SpacePushResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -666,7 +726,7 @@ func (m *SpacePullRequest) Reset() { *m = SpacePullRequest{} }
func (m *SpacePullRequest) String() string { return proto.CompactTextString(m) }
func (*SpacePullRequest) ProtoMessage() {}
func (*SpacePullRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{8}
return fileDescriptor_80e49f1f4ac27799, []int{9}
}
func (m *SpacePullRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -719,7 +779,7 @@ func (m *SpacePullResponse) Reset() { *m = SpacePullResponse{} }
func (m *SpacePullResponse) String() string { return proto.CompactTextString(m) }
func (*SpacePullResponse) ProtoMessage() {}
func (*SpacePullResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{9}
return fileDescriptor_80e49f1f4ac27799, []int{10}
}
func (m *SpacePullResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -776,7 +836,7 @@ func (m *SpacePayload) Reset() { *m = SpacePayload{} }
func (m *SpacePayload) String() string { return proto.CompactTextString(m) }
func (*SpacePayload) ProtoMessage() {}
func (*SpacePayload) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{10}
return fileDescriptor_80e49f1f4ac27799, []int{11}
}
func (m *SpacePayload) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -862,7 +922,7 @@ func (m *SpaceHeader) Reset() { *m = SpaceHeader{} }
func (m *SpaceHeader) String() string { return proto.CompactTextString(m) }
func (*SpaceHeader) ProtoMessage() {}
func (*SpaceHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{11}
return fileDescriptor_80e49f1f4ac27799, []int{12}
}
func (m *SpaceHeader) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -951,7 +1011,7 @@ 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_80e49f1f4ac27799, []int{12}
return fileDescriptor_80e49f1f4ac27799, []int{13}
}
func (m *RawSpaceHeader) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1012,7 +1072,7 @@ 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_80e49f1f4ac27799, []int{13}
return fileDescriptor_80e49f1f4ac27799, []int{14}
}
func (m *RawSpaceHeaderWithId) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1076,7 +1136,7 @@ func (m *SpaceSettingsContent) Reset() { *m = SpaceSettingsContent{} }
func (m *SpaceSettingsContent) String() string { return proto.CompactTextString(m) }
func (*SpaceSettingsContent) ProtoMessage() {}
func (*SpaceSettingsContent) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{14}
return fileDescriptor_80e49f1f4ac27799, []int{15}
}
func (m *SpaceSettingsContent) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1167,7 +1227,7 @@ func (m *ObjectDelete) Reset() { *m = ObjectDelete{} }
func (m *ObjectDelete) String() string { return proto.CompactTextString(m) }
func (*ObjectDelete) ProtoMessage() {}
func (*ObjectDelete) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{15}
return fileDescriptor_80e49f1f4ac27799, []int{16}
}
func (m *ObjectDelete) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1220,7 +1280,7 @@ func (m *SpaceDelete) Reset() { *m = SpaceDelete{} }
func (m *SpaceDelete) String() string { return proto.CompactTextString(m) }
func (*SpaceDelete) ProtoMessage() {}
func (*SpaceDelete) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{16}
return fileDescriptor_80e49f1f4ac27799, []int{17}
}
func (m *SpaceDelete) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1274,7 +1334,7 @@ func (m *SpaceSettingsSnapshot) Reset() { *m = SpaceSettingsSnapshot{} }
func (m *SpaceSettingsSnapshot) String() string { return proto.CompactTextString(m) }
func (*SpaceSettingsSnapshot) ProtoMessage() {}
func (*SpaceSettingsSnapshot) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{17}
return fileDescriptor_80e49f1f4ac27799, []int{18}
}
func (m *SpaceSettingsSnapshot) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1335,7 +1395,7 @@ func (m *SettingsData) Reset() { *m = SettingsData{} }
func (m *SettingsData) String() string { return proto.CompactTextString(m) }
func (*SettingsData) ProtoMessage() {}
func (*SettingsData) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{18}
return fileDescriptor_80e49f1f4ac27799, []int{19}
}
func (m *SettingsData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1395,7 +1455,7 @@ func (m *SpaceSubscription) Reset() { *m = SpaceSubscription{} }
func (m *SpaceSubscription) String() string { return proto.CompactTextString(m) }
func (*SpaceSubscription) ProtoMessage() {}
func (*SpaceSubscription) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{19}
return fileDescriptor_80e49f1f4ac27799, []int{20}
}
func (m *SpaceSubscription) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1456,7 +1516,7 @@ func (m *AclAddRecordRequest) Reset() { *m = AclAddRecordRequest{} }
func (m *AclAddRecordRequest) String() string { return proto.CompactTextString(m) }
func (*AclAddRecordRequest) ProtoMessage() {}
func (*AclAddRecordRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{20}
return fileDescriptor_80e49f1f4ac27799, []int{21}
}
func (m *AclAddRecordRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1517,7 +1577,7 @@ func (m *AclAddRecordResponse) Reset() { *m = AclAddRecordResponse{} }
func (m *AclAddRecordResponse) String() string { return proto.CompactTextString(m) }
func (*AclAddRecordResponse) ProtoMessage() {}
func (*AclAddRecordResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{21}
return fileDescriptor_80e49f1f4ac27799, []int{22}
}
func (m *AclAddRecordResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1579,7 +1639,7 @@ func (m *AclGetRecordsRequest) Reset() { *m = AclGetRecordsRequest{} }
func (m *AclGetRecordsRequest) String() string { return proto.CompactTextString(m) }
func (*AclGetRecordsRequest) ProtoMessage() {}
func (*AclGetRecordsRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{22}
return fileDescriptor_80e49f1f4ac27799, []int{23}
}
func (m *AclGetRecordsRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1639,7 +1699,7 @@ func (m *AclGetRecordsResponse) Reset() { *m = AclGetRecordsResponse{} }
func (m *AclGetRecordsResponse) String() string { return proto.CompactTextString(m) }
func (*AclGetRecordsResponse) ProtoMessage() {}
func (*AclGetRecordsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_80e49f1f4ac27799, []int{23}
return fileDescriptor_80e49f1f4ac27799, []int{24}
}
func (m *AclGetRecordsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1690,6 +1750,7 @@ func init() {
proto.RegisterType((*HeadSyncRange)(nil), "spacesync.HeadSyncRange")
proto.RegisterType((*HeadSyncResult)(nil), "spacesync.HeadSyncResult")
proto.RegisterType((*HeadSyncResultElement)(nil), "spacesync.HeadSyncResultElement")
proto.RegisterType((*EncodedHeadSyncResults)(nil), "spacesync.EncodedHeadSyncResults")
proto.RegisterType((*HeadSyncRequest)(nil), "spacesync.HeadSyncRequest")
proto.RegisterType((*HeadSyncResponse)(nil), "spacesync.HeadSyncResponse")
proto.RegisterType((*ObjectSyncMessage)(nil), "spacesync.ObjectSyncMessage")
@ -1718,89 +1779,90 @@ func init() {
}
var fileDescriptor_80e49f1f4ac27799 = []byte{
// 1298 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xcb, 0x73, 0xdb, 0x44,
0x18, 0xb7, 0x14, 0xc7, 0x8f, 0x2f, 0x8a, 0xab, 0x6e, 0xdc, 0xc6, 0xb8, 0x1d, 0xd7, 0xa3, 0x61,
0x20, 0xd3, 0x43, 0xdb, 0xb8, 0x0c, 0x33, 0x2d, 0x70, 0x48, 0x93, 0x94, 0x08, 0x48, 0x93, 0x59,
0xb7, 0x74, 0x86, 0x19, 0x0e, 0x1b, 0x69, 0x13, 0x0b, 0x64, 0xc9, 0x68, 0xd7, 0x6d, 0x7c, 0xe4,
0xc4, 0x8d, 0xe1, 0x0c, 0xff, 0x10, 0xc7, 0x72, 0xe3, 0xc8, 0x24, 0x77, 0xfe, 0x02, 0x0e, 0xcc,
0xae, 0x56, 0x2f, 0x5b, 0x0e, 0x65, 0x7a, 0x89, 0xf5, 0xbd, 0x7e, 0xdf, 0x73, 0xbf, 0xdd, 0xc0,
0xb6, 0x13, 0x8e, 0xc7, 0x61, 0xc0, 0x26, 0xc4, 0xa1, 0xf7, 0xe5, 0x5f, 0x36, 0x0b, 0x9c, 0x49,
0x14, 0xf2, 0xf0, 0xbe, 0xfc, 0xcb, 0x32, 0xee, 0x3d, 0xc9, 0x40, 0xcd, 0x94, 0x61, 0x51, 0x58,
0x3f, 0xa0, 0xc4, 0x1d, 0xce, 0x02, 0x07, 0x93, 0xe0, 0x8c, 0x22, 0x04, 0xd5, 0xd3, 0x28, 0x1c,
0x77, 0xb4, 0xbe, 0xb6, 0x55, 0xc5, 0xf2, 0x1b, 0xb5, 0x40, 0xe7, 0x61, 0x47, 0x97, 0x1c, 0x9d,
0x87, 0xa8, 0x0d, 0xab, 0xbe, 0x37, 0xf6, 0x78, 0x67, 0xa5, 0xaf, 0x6d, 0xad, 0xe3, 0x98, 0x40,
0x5d, 0x68, 0x50, 0x9f, 0x8e, 0x69, 0xc0, 0x59, 0xa7, 0xda, 0xd7, 0xb6, 0x1a, 0x38, 0xa5, 0xad,
0x73, 0x68, 0xa5, 0x6e, 0x28, 0x9b, 0xfa, 0x5c, 0xf8, 0x19, 0x11, 0x36, 0x92, 0x7e, 0x0c, 0x2c,
0xbf, 0xd1, 0xa7, 0x39, 0x04, 0xbd, 0xbf, 0xb2, 0xb5, 0x36, 0xe8, 0xdf, 0xcb, 0x62, 0x2f, 0x02,
0xec, 0xc7, 0x8a, 0x99, 0x0f, 0x11, 0x95, 0x13, 0x4e, 0x83, 0x34, 0x2a, 0x49, 0x58, 0x9f, 0xc0,
0x8d, 0x52, 0x43, 0x91, 0x94, 0xe7, 0x4a, 0xf7, 0x4d, 0xac, 0x7b, 0xae, 0x0c, 0x88, 0x12, 0x57,
0xa6, 0xd9, 0xc4, 0xf2, 0xdb, 0xfa, 0x59, 0x83, 0x6b, 0x99, 0xf5, 0x0f, 0x53, 0xca, 0x38, 0xea,
0x40, 0x5d, 0xc6, 0x64, 0x27, 0xc6, 0x09, 0x89, 0x1e, 0x40, 0x2d, 0x12, 0x35, 0x4c, 0x82, 0xef,
0x94, 0x05, 0x2f, 0x14, 0xb0, 0xd2, 0x43, 0xf7, 0xa1, 0xe1, 0x7a, 0xa7, 0xa7, 0xcf, 0x67, 0x13,
0x2a, 0xa3, 0x6e, 0x0d, 0x36, 0x72, 0x36, 0x7b, 0x4a, 0x84, 0x53, 0x25, 0xeb, 0x1c, 0xcc, 0x5c,
0x36, 0x93, 0x30, 0x60, 0x14, 0x3d, 0x84, 0x7a, 0x24, 0x33, 0x63, 0x1d, 0x4d, 0xfa, 0x7d, 0x6f,
0x69, 0xd1, 0x70, 0xa2, 0x59, 0xf0, 0xac, 0xbf, 0x8d, 0xe7, 0xdf, 0x34, 0xb8, 0x7e, 0x74, 0xf2,
0x1d, 0x75, 0xb8, 0x80, 0x3b, 0xa4, 0x8c, 0x91, 0x33, 0x7a, 0x45, 0x31, 0x6e, 0x43, 0x33, 0x8a,
0x2b, 0x66, 0x27, 0x35, 0xcd, 0x18, 0xc2, 0x2e, 0xa2, 0x13, 0x7f, 0x66, 0xbb, 0x32, 0xef, 0x26,
0x4e, 0x48, 0x21, 0x99, 0x90, 0x99, 0x1f, 0x12, 0x57, 0x0e, 0x91, 0x81, 0x13, 0x52, 0xcc, 0x57,
0x28, 0x03, 0xb0, 0xdd, 0xce, 0xaa, 0x34, 0x4a, 0x69, 0x8b, 0x82, 0x39, 0x14, 0x8e, 0x8f, 0xa7,
0x6c, 0x94, 0x34, 0x6a, 0x3b, 0x43, 0x12, 0xb1, 0xad, 0x0d, 0x36, 0x73, 0x19, 0xc6, 0xda, 0xb1,
0x38, 0x73, 0xd1, 0x03, 0xd8, 0x8d, 0xa8, 0x4b, 0x03, 0xee, 0x11, 0x5f, 0x46, 0x6d, 0xe0, 0x1c,
0xc7, 0xda, 0x80, 0xeb, 0x39, 0x37, 0x71, 0xfd, 0x2d, 0x2b, 0xf5, 0xed, 0xfb, 0x89, 0xef, 0xb9,
0xe1, 0xb2, 0x9e, 0xa6, 0x86, 0x42, 0x47, 0x35, 0xee, 0xff, 0x07, 0x68, 0xfd, 0xa8, 0x83, 0x91,
0x97, 0xa0, 0x1d, 0x58, 0x93, 0x36, 0xa2, 0xcf, 0x34, 0x52, 0x38, 0x77, 0x72, 0x38, 0x98, 0xbc,
0x1e, 0x66, 0x0a, 0x2f, 0x3d, 0x3e, 0xb2, 0x5d, 0x9c, 0xb7, 0x11, 0x49, 0x13, 0xc7, 0x57, 0x80,
0x49, 0xd2, 0x19, 0x07, 0x59, 0x60, 0x64, 0x54, 0xda, 0xb0, 0x02, 0x0f, 0x0d, 0xa0, 0x2d, 0x21,
0x87, 0x94, 0x73, 0x2f, 0x38, 0x63, 0xc7, 0x85, 0x16, 0x96, 0xca, 0xd0, 0xc7, 0x70, 0xb3, 0x8c,
0x9f, 0x76, 0x77, 0x89, 0xd4, 0xfa, 0x43, 0x83, 0xb5, 0x5c, 0x4a, 0x62, 0x2e, 0x3c, 0xd9, 0x20,
0x3e, 0x53, 0xdb, 0x24, 0xa5, 0xc5, 0x14, 0x72, 0x6f, 0x4c, 0x19, 0x27, 0xe3, 0x89, 0x4c, 0x6d,
0x05, 0x67, 0x0c, 0x21, 0x95, 0x3e, 0xd2, 0xf3, 0xd7, 0xc4, 0x19, 0x03, 0x7d, 0x00, 0x2d, 0x31,
0x94, 0x9e, 0x43, 0xb8, 0x17, 0x06, 0x5f, 0xd2, 0x99, 0xcc, 0xa6, 0x8a, 0xe7, 0xb8, 0x62, 0x71,
0x30, 0x4a, 0xe3, 0xa8, 0x0d, 0x2c, 0xbf, 0xd1, 0x3d, 0x40, 0xb9, 0x12, 0x27, 0xd5, 0xa8, 0x49,
0x8d, 0x12, 0x89, 0x75, 0x0c, 0xad, 0x62, 0xa3, 0x50, 0x7f, 0xb1, 0xb1, 0x46, 0xb1, 0x6f, 0x22,
0x7a, 0xef, 0x2c, 0x20, 0x7c, 0x1a, 0x51, 0xd5, 0xb6, 0x8c, 0x61, 0xed, 0x41, 0xbb, 0xac, 0xf5,
0xf2, 0x5c, 0x92, 0xd7, 0x05, 0xd4, 0x8c, 0xa1, 0xe6, 0x56, 0x4f, 0xe7, 0xf6, 0x57, 0x0d, 0xda,
0xc3, 0x7c, 0x1b, 0x76, 0xc3, 0x80, 0x8b, 0xed, 0xf9, 0x19, 0x18, 0xf1, 0xe1, 0xdb, 0xa3, 0x3e,
0xe5, 0xb4, 0x64, 0x80, 0x8f, 0x72, 0xe2, 0x83, 0x0a, 0x2e, 0xa8, 0xa3, 0xc7, 0x2a, 0x3b, 0x65,
0xad, 0x4b, 0xeb, 0x9b, 0xf3, 0xe3, 0x9f, 0x1a, 0xe7, 0x95, 0x9f, 0xd4, 0x61, 0xf5, 0x15, 0xf1,
0xa7, 0xd4, 0xea, 0x81, 0x91, 0x77, 0xb2, 0x70, 0xe8, 0x1e, 0xaa, 0x39, 0x51, 0xe2, 0xf7, 0x61,
0xdd, 0x95, 0x5f, 0xd1, 0x31, 0xa5, 0x51, 0xba, 0xb1, 0x8a, 0x4c, 0xeb, 0x5b, 0xb8, 0x51, 0x48,
0x78, 0x18, 0x90, 0x09, 0x1b, 0x85, 0x5c, 0x1c, 0x93, 0x58, 0xd3, 0xb5, 0xdd, 0x78, 0xd3, 0x36,
0x71, 0x8e, 0xb3, 0x08, 0xaf, 0x97, 0xc1, 0xff, 0xa4, 0x81, 0x91, 0x40, 0xef, 0x11, 0x4e, 0xd0,
0x23, 0xa8, 0x3b, 0x71, 0x4d, 0xd5, 0xf6, 0xbe, 0x33, 0x5f, 0x85, 0xb9, 0xd2, 0xe3, 0x44, 0x5f,
0x5c, 0x97, 0x4c, 0x45, 0xa7, 0x2a, 0xd8, 0x5f, 0x66, 0x9b, 0x64, 0x81, 0x53, 0x0b, 0xeb, 0x7b,
0xb5, 0x92, 0x86, 0xd3, 0x13, 0xe6, 0x44, 0xde, 0x44, 0x8c, 0xb3, 0x38, 0x4b, 0x6a, 0x81, 0x27,
0x29, 0xa6, 0x34, 0x7a, 0x0c, 0x35, 0xe2, 0x08, 0x2d, 0x75, 0x61, 0x58, 0x0b, 0xce, 0x72, 0x48,
0x3b, 0x52, 0x13, 0x2b, 0x0b, 0xcb, 0x86, 0x8d, 0x1d, 0xc7, 0xdf, 0x71, 0x5d, 0x4c, 0x9d, 0x30,
0x72, 0xff, 0xfb, 0x2e, 0xcd, 0x5d, 0x03, 0x7a, 0xe1, 0x1a, 0xb0, 0xbe, 0x82, 0x76, 0x11, 0x4a,
0x6d, 0xd3, 0x2e, 0x34, 0x22, 0xc9, 0x49, 0xc1, 0x52, 0xfa, 0x0a, 0xb4, 0x2f, 0x24, 0xda, 0xe7,
0x94, 0xc7, 0x68, 0xec, 0xad, 0x22, 0x23, 0x8e, 0x7f, 0x90, 0x3d, 0x15, 0x12, 0xd2, 0xda, 0x86,
0x1b, 0x73, 0x58, 0x2a, 0x34, 0x79, 0xdb, 0x49, 0x96, 0x2c, 0xaa, 0x81, 0x13, 0xf2, 0xee, 0xdf,
0x1a, 0x34, 0xf6, 0xa3, 0x68, 0x37, 0x74, 0x29, 0x43, 0x2d, 0x80, 0x17, 0x01, 0x3d, 0x9f, 0x50,
0x87, 0x53, 0xd7, 0xac, 0x20, 0x53, 0xed, 0xfa, 0x43, 0x8f, 0x31, 0x2f, 0x38, 0x33, 0x35, 0x74,
0x4d, 0x4d, 0xf4, 0xfe, 0xb9, 0xc7, 0x38, 0x33, 0x75, 0xb4, 0x01, 0xd7, 0x24, 0xe3, 0x59, 0xc8,
0xed, 0x60, 0x97, 0x38, 0x23, 0x6a, 0xae, 0x20, 0x04, 0x2d, 0xc9, 0xb4, 0x59, 0x3c, 0xf9, 0xae,
0x59, 0x45, 0x1d, 0x68, 0xcb, 0x09, 0x64, 0xcf, 0x42, 0xae, 0xe2, 0xf2, 0x4e, 0x7c, 0x6a, 0xae,
0xa2, 0x36, 0x98, 0x98, 0x3a, 0xd4, 0x9b, 0x70, 0x9b, 0xd9, 0xc1, 0x2b, 0xe2, 0x7b, 0xae, 0x59,
0x13, 0x18, 0x8a, 0x50, 0x2b, 0xca, 0xac, 0x0b, 0xcd, 0xbd, 0x69, 0xbc, 0xfa, 0xa8, 0xaa, 0x93,
0xd9, 0x40, 0xb7, 0x60, 0xf3, 0x79, 0x18, 0x1e, 0x92, 0x60, 0xa6, 0x78, 0xec, 0x69, 0x14, 0x8e,
0x85, 0x33, 0xb3, 0x29, 0x02, 0xde, 0x8f, 0xa2, 0x30, 0x3a, 0x3a, 0x3d, 0x65, 0x94, 0x9b, 0xee,
0xdd, 0x47, 0xb0, 0xb9, 0x64, 0x56, 0xd0, 0x3a, 0x34, 0x15, 0xf7, 0x84, 0x9a, 0x15, 0x61, 0xfa,
0x22, 0x60, 0x29, 0x43, 0xbb, 0xfb, 0x21, 0x34, 0x92, 0x77, 0x09, 0x5a, 0x83, 0xba, 0x1d, 0x78,
0xe2, 0x4e, 0x36, 0x2b, 0xa8, 0x06, 0xfa, 0xd7, 0xdb, 0xa6, 0x26, 0x7f, 0x07, 0xa6, 0x3e, 0xf8,
0xa7, 0x0a, 0xcd, 0xd8, 0xc9, 0x2c, 0x70, 0xd0, 0x2e, 0x34, 0x92, 0x47, 0x10, 0xea, 0x96, 0xbe,
0x8c, 0x64, 0xd4, 0xdd, 0x5b, 0xe5, 0xaf, 0xa6, 0xb8, 0x83, 0x4f, 0x15, 0xa2, 0xb8, 0xf8, 0xd1,
0xad, 0x85, 0x6b, 0x3a, 0x7b, 0x75, 0x74, 0x6f, 0x97, 0x0b, 0x17, 0x70, 0x7c, 0xbf, 0x0c, 0x27,
0x7d, 0x41, 0x94, 0xe1, 0xe4, 0x9e, 0x0e, 0x18, 0xcc, 0xec, 0x31, 0x36, 0xe4, 0x11, 0x25, 0x63,
0x74, 0x7b, 0x61, 0xf9, 0xe6, 0x5e, 0x6a, 0xdd, 0x2b, 0xa5, 0x5b, 0xda, 0x03, 0x0d, 0x1d, 0x00,
0x64, 0x82, 0x77, 0x41, 0x43, 0x2f, 0x61, 0x33, 0x63, 0xaa, 0x84, 0xde, 0x3d, 0xc8, 0x07, 0x1a,
0x3a, 0x02, 0x23, 0x7f, 0xf6, 0x51, 0x2f, 0xa7, 0x5f, 0xb2, 0x5f, 0xba, 0x77, 0x96, 0xca, 0xd3,
0x3a, 0xae, 0x17, 0x8e, 0x2c, 0x9a, 0xb3, 0x58, 0x58, 0x0c, 0xdd, 0xfe, 0x72, 0x85, 0x18, 0xf3,
0xc9, 0x47, 0xbf, 0x5f, 0xf4, 0xb4, 0x37, 0x17, 0x3d, 0xed, 0xaf, 0x8b, 0x9e, 0xf6, 0xcb, 0x65,
0xaf, 0xf2, 0xe6, 0xb2, 0x57, 0xf9, 0xf3, 0xb2, 0x57, 0xf9, 0xa6, 0xbb, 0xfc, 0x5f, 0xb5, 0x93,
0x9a, 0xfc, 0x79, 0xf8, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x2e, 0x04, 0x49, 0x74, 0xcf, 0x0d,
0x00, 0x00,
// 1328 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0x4d, 0x6f, 0x1b, 0xc5,
0x1b, 0xf7, 0x6e, 0xde, 0xec, 0x27, 0x1b, 0x77, 0x3b, 0x71, 0x1b, 0xff, 0xdd, 0xca, 0xb5, 0x56,
0xd5, 0x9f, 0xa8, 0x87, 0xb6, 0x49, 0x11, 0x52, 0x0b, 0x1c, 0xd2, 0x24, 0x25, 0x06, 0xd2, 0x44,
0xe3, 0x96, 0x4a, 0x48, 0x1c, 0x26, 0xbb, 0x4f, 0x92, 0x85, 0xf5, 0xae, 0xd9, 0x19, 0xb7, 0xf5,
0x91, 0x13, 0x37, 0xc4, 0x19, 0x24, 0x3e, 0x0f, 0xc7, 0x72, 0xe3, 0x88, 0xda, 0x3b, 0x9f, 0x80,
0x03, 0x9a, 0xd9, 0xd9, 0x37, 0x7b, 0x1d, 0x0a, 0xbd, 0xc4, 0xfb, 0xbc, 0xfd, 0x9e, 0xd7, 0x79,
0x66, 0x02, 0x5b, 0x6e, 0x34, 0x1c, 0x46, 0x21, 0x1f, 0x31, 0x17, 0xef, 0xa8, 0xbf, 0x7c, 0x12,
0xba, 0xa3, 0x38, 0x12, 0xd1, 0x1d, 0xf5, 0x97, 0xe7, 0xdc, 0xdb, 0x8a, 0x41, 0x1a, 0x19, 0xc3,
0x41, 0x58, 0x3b, 0x40, 0xe6, 0x0d, 0x26, 0xa1, 0x4b, 0x59, 0x78, 0x86, 0x84, 0xc0, 0xe2, 0x69,
0x1c, 0x0d, 0xdb, 0x46, 0xcf, 0xd8, 0x5c, 0xa4, 0xea, 0x9b, 0x34, 0xc1, 0x14, 0x51, 0xdb, 0x54,
0x1c, 0x53, 0x44, 0xa4, 0x05, 0x4b, 0x81, 0x3f, 0xf4, 0x45, 0x7b, 0xa1, 0x67, 0x6c, 0xae, 0xd1,
0x84, 0x20, 0x1d, 0xa8, 0x63, 0x80, 0x43, 0x0c, 0x05, 0x6f, 0x2f, 0xf6, 0x8c, 0xcd, 0x3a, 0xcd,
0x68, 0xe7, 0x25, 0x34, 0x33, 0x37, 0xc8, 0xc7, 0x81, 0x90, 0x7e, 0xce, 0x19, 0x3f, 0x57, 0x7e,
0x2c, 0xaa, 0xbe, 0xc9, 0x47, 0x05, 0x04, 0xb3, 0xb7, 0xb0, 0xb9, 0xba, 0xdd, 0xbb, 0x9d, 0xc7,
0x5e, 0x06, 0xd8, 0x4f, 0x14, 0x73, 0x1f, 0x32, 0x2a, 0x37, 0x1a, 0x87, 0x59, 0x54, 0x8a, 0x70,
0x3e, 0x84, 0x2b, 0x95, 0x86, 0x32, 0x29, 0xdf, 0x53, 0xee, 0x1b, 0xd4, 0xf4, 0x3d, 0x15, 0x10,
0x32, 0x4f, 0xa5, 0xd9, 0xa0, 0xea, 0xdb, 0x39, 0x84, 0xab, 0xfb, 0xa1, 0x1b, 0x79, 0xe8, 0x95,
0x31, 0x38, 0xb9, 0x07, 0x2b, 0x71, 0xf2, 0xd9, 0x36, 0x54, 0xa4, 0xff, 0x9b, 0x1b, 0x29, 0x4d,
0x35, 0x9d, 0x1f, 0x0c, 0xb8, 0x94, 0xcb, 0xbe, 0x1d, 0x23, 0x17, 0xa4, 0x0d, 0x2b, 0xca, 0xb0,
0x9f, 0xc6, 0x92, 0x92, 0xe4, 0x2e, 0x2c, 0xc7, 0xb2, 0x25, 0x69, 0x2d, 0xda, 0x55, 0x1e, 0xa4,
0x02, 0xd5, 0x7a, 0xe4, 0x0e, 0xd4, 0x3d, 0xff, 0xf4, 0xf4, 0xc9, 0x64, 0x84, 0xaa, 0x08, 0xcd,
0xed, 0xf5, 0x82, 0xcd, 0x9e, 0x16, 0xd1, 0x4c, 0xc9, 0xf9, 0xc5, 0x00, 0xbb, 0x10, 0xec, 0x28,
0x0a, 0x39, 0xfe, 0xa7, 0xd4, 0x4a, 0xae, 0xcd, 0xb7, 0x70, 0x4d, 0x6e, 0xc2, 0x1a, 0x26, 0xa5,
0x4d, 0xa0, 0x54, 0xc0, 0x16, 0x2d, 0x33, 0x9d, 0x9f, 0x0d, 0xb8, 0x7c, 0x74, 0xf2, 0x35, 0xba,
0x42, 0x3a, 0x3d, 0x44, 0xce, 0xd9, 0x19, 0x5e, 0x50, 0xb3, 0xeb, 0xd0, 0x88, 0x93, 0xc2, 0xf6,
0xd3, 0x4e, 0xe6, 0x0c, 0x69, 0x17, 0xe3, 0x28, 0x98, 0xf4, 0x3d, 0xe5, 0xad, 0x41, 0x53, 0x52,
0x4a, 0x46, 0x6c, 0x12, 0x44, 0xcc, 0x53, 0xa3, 0x6b, 0xd1, 0x94, 0x94, 0x53, 0x1d, 0xa9, 0x00,
0xfa, 0x5e, 0x7b, 0x49, 0x19, 0x65, 0xb4, 0x83, 0x60, 0x0f, 0xa4, 0xe3, 0xe3, 0x31, 0x3f, 0x4f,
0xfb, 0xb9, 0x95, 0x23, 0xc9, 0xd8, 0x56, 0xb7, 0x37, 0x0a, 0x75, 0x48, 0xb4, 0x13, 0x71, 0xee,
0xa2, 0x0b, 0xb0, 0x1b, 0xa3, 0x87, 0xa1, 0xf0, 0x59, 0xa0, 0xa2, 0xb6, 0x68, 0x81, 0xe3, 0xac,
0xc3, 0xe5, 0x82, 0x9b, 0xa4, 0x4b, 0x8e, 0x93, 0xf9, 0x0e, 0x82, 0xd4, 0xf7, 0xd4, 0x48, 0x3b,
0x8f, 0x32, 0x43, 0xa9, 0xa3, 0xdb, 0xfb, 0xef, 0x03, 0x74, 0xbe, 0x33, 0xc1, 0x2a, 0x4a, 0xc8,
0x0e, 0xac, 0x2a, 0x1b, 0x39, 0x0d, 0x18, 0x6b, 0x9c, 0x1b, 0x05, 0x1c, 0xca, 0x5e, 0x0c, 0x72,
0x85, 0x67, 0xbe, 0x38, 0xef, 0x7b, 0xb4, 0x68, 0x23, 0x93, 0x66, 0x6e, 0xa0, 0x01, 0xd3, 0xa4,
0x73, 0x0e, 0x71, 0xc0, 0xca, 0xa9, 0xac, 0x61, 0x25, 0x1e, 0xd9, 0x86, 0x96, 0x82, 0x1c, 0xa0,
0x10, 0x7e, 0x78, 0xc6, 0x8f, 0x4b, 0x2d, 0xac, 0x94, 0x91, 0x0f, 0xe0, 0x6a, 0x15, 0x3f, 0xeb,
0xee, 0x1c, 0xa9, 0xf3, 0x9b, 0x01, 0xab, 0x85, 0x94, 0xe4, 0x5c, 0xf8, 0xaa, 0x41, 0x62, 0xa2,
0x77, 0x58, 0x46, 0xcb, 0x29, 0x14, 0xfe, 0x10, 0xb9, 0x60, 0xc3, 0x91, 0x4a, 0x6d, 0x81, 0xe6,
0x0c, 0x29, 0x55, 0x3e, 0xb2, 0x63, 0xda, 0xa0, 0x39, 0x83, 0xfc, 0x1f, 0x9a, 0x72, 0x28, 0x7d,
0x97, 0x09, 0x3f, 0x0a, 0x3f, 0xc3, 0x89, 0xca, 0x66, 0x91, 0x4e, 0x71, 0xe5, 0xba, 0xe2, 0x88,
0x49, 0xd4, 0x16, 0x55, 0xdf, 0xe4, 0x36, 0x90, 0x42, 0x89, 0xd3, 0x6a, 0x2c, 0x2b, 0x8d, 0x0a,
0x89, 0x73, 0x0c, 0xcd, 0x72, 0xa3, 0x48, 0x6f, 0xb6, 0xb1, 0x56, 0xb9, 0x6f, 0x32, 0x7a, 0xff,
0x2c, 0x64, 0x62, 0x1c, 0xa3, 0x6e, 0x5b, 0xce, 0x70, 0xf6, 0xa0, 0x55, 0xd5, 0x7a, 0x75, 0x2e,
0xd9, 0x8b, 0x12, 0x6a, 0xce, 0xd0, 0x73, 0x6b, 0x66, 0x73, 0xfb, 0x93, 0x01, 0xad, 0x41, 0xb1,
0x0d, 0xbb, 0x51, 0x28, 0xe4, 0xce, 0xfe, 0x18, 0xac, 0xe4, 0xf0, 0xed, 0x61, 0x80, 0x02, 0x2b,
0x06, 0xf8, 0xa8, 0x20, 0x3e, 0xa8, 0xd1, 0x92, 0x3a, 0x79, 0xa0, 0xb3, 0xd3, 0xd6, 0xa6, 0xb2,
0xbe, 0x3a, 0x3d, 0xfe, 0x99, 0x71, 0x51, 0xf9, 0xe1, 0x0a, 0x2c, 0x3d, 0x67, 0xc1, 0x18, 0x9d,
0x2e, 0x58, 0x45, 0x27, 0x33, 0x87, 0xee, 0x9e, 0x9e, 0x13, 0x2d, 0xbe, 0x09, 0x6b, 0x9e, 0xfa,
0x8a, 0x8f, 0x11, 0xe3, 0x6c, 0x63, 0x95, 0x99, 0xce, 0x57, 0x70, 0xa5, 0x94, 0xf0, 0x20, 0x64,
0x23, 0x7e, 0x1e, 0x09, 0x79, 0x4c, 0x12, 0x4d, 0xaf, 0xef, 0x25, 0xfb, 0xb8, 0x41, 0x0b, 0x9c,
0x59, 0x78, 0xb3, 0x0a, 0xfe, 0x7b, 0x03, 0xac, 0x14, 0x7a, 0x8f, 0x09, 0x46, 0xee, 0xc3, 0x8a,
0x9b, 0xd4, 0x54, 0xef, 0xf8, 0x1b, 0xd3, 0x55, 0x98, 0x2a, 0x3d, 0x4d, 0xf5, 0xe5, 0x25, 0xcd,
0x75, 0x74, 0xba, 0x82, 0xbd, 0x79, 0xb6, 0x69, 0x16, 0x34, 0xb3, 0x70, 0xbe, 0xd1, 0x2b, 0x69,
0x30, 0x3e, 0xe1, 0x6e, 0xec, 0x8f, 0xe4, 0x38, 0xcb, 0xb3, 0xa4, 0x17, 0x78, 0x9a, 0x62, 0x46,
0x93, 0x07, 0xb0, 0xcc, 0x5c, 0xa9, 0xa5, 0xaf, 0x15, 0x67, 0xc6, 0x59, 0x01, 0x69, 0x47, 0x69,
0x52, 0x6d, 0xe1, 0xf4, 0x61, 0x7d, 0xc7, 0x0d, 0x76, 0x3c, 0x8f, 0xa2, 0x1b, 0xc5, 0xde, 0x3f,
0x5f, 0xb9, 0x85, 0x6b, 0xc0, 0x2c, 0x5d, 0x03, 0xce, 0xe7, 0xd0, 0x2a, 0x43, 0xe9, 0x6d, 0xda,
0x81, 0x7a, 0xac, 0x38, 0x19, 0x58, 0x46, 0x5f, 0x80, 0xf6, 0xa9, 0x42, 0xfb, 0x04, 0x45, 0x82,
0xc6, 0xdf, 0x2a, 0x32, 0xe6, 0x06, 0x07, 0xf9, 0x03, 0x25, 0x25, 0x9d, 0x2d, 0xb8, 0x32, 0x85,
0xa5, 0x43, 0x53, 0xb7, 0x9d, 0x62, 0xa9, 0xa2, 0x5a, 0x34, 0x25, 0x6f, 0xfd, 0x69, 0x40, 0x7d,
0x3f, 0x8e, 0x77, 0x23, 0x0f, 0x39, 0x69, 0x02, 0x3c, 0x0d, 0xf1, 0xe5, 0x08, 0x5d, 0x81, 0x9e,
0x5d, 0x23, 0xb6, 0xde, 0xf5, 0x87, 0x3e, 0xe7, 0x7e, 0x78, 0x66, 0x1b, 0xe4, 0x92, 0x9e, 0xe8,
0xfd, 0x97, 0x3e, 0x17, 0xdc, 0x36, 0xc9, 0x3a, 0x5c, 0x52, 0x8c, 0xc7, 0x91, 0xe8, 0x87, 0xbb,
0xcc, 0x3d, 0x47, 0x7b, 0x81, 0x10, 0x68, 0x2a, 0x66, 0x9f, 0x27, 0x93, 0xef, 0xd9, 0x8b, 0xa4,
0x0d, 0x2d, 0x35, 0x81, 0xfc, 0x71, 0x24, 0x74, 0x5c, 0xfe, 0x49, 0x80, 0xf6, 0x12, 0x69, 0x81,
0x4d, 0xd1, 0x45, 0x7f, 0x24, 0xfa, 0xbc, 0x1f, 0x3e, 0x67, 0x81, 0xef, 0xd9, 0xcb, 0x12, 0x43,
0x13, 0x7a, 0x45, 0xd9, 0x2b, 0x52, 0x73, 0x6f, 0x9c, 0xac, 0x3e, 0xd4, 0x75, 0xb2, 0xeb, 0xe4,
0x1a, 0x6c, 0x3c, 0x89, 0xa2, 0x43, 0x16, 0x4e, 0x34, 0x8f, 0x3f, 0x8a, 0xa3, 0xa1, 0x74, 0x66,
0x37, 0x64, 0xc0, 0xfb, 0x71, 0x1c, 0xc5, 0x47, 0xa7, 0xa7, 0x1c, 0x85, 0xed, 0xdd, 0xba, 0x0f,
0x1b, 0x73, 0x66, 0x85, 0xac, 0x41, 0x43, 0x73, 0x4f, 0xd0, 0xae, 0x49, 0xd3, 0xa7, 0x21, 0xcf,
0x18, 0xc6, 0xad, 0xf7, 0xa0, 0x9e, 0xbe, 0x5e, 0xc8, 0x2a, 0xac, 0xf4, 0x43, 0x5f, 0xde, 0xc9,
0x76, 0x8d, 0x2c, 0x83, 0xf9, 0xc5, 0x96, 0x6d, 0xa8, 0xdf, 0x6d, 0xdb, 0xdc, 0xfe, 0x6b, 0x11,
0x1a, 0x89, 0x93, 0x49, 0xe8, 0x92, 0x5d, 0xa8, 0xa7, 0x4f, 0x25, 0xd2, 0xa9, 0x7c, 0x3f, 0xa9,
0xa8, 0x3b, 0xd7, 0xaa, 0xdf, 0x56, 0x49, 0x07, 0x1f, 0x69, 0x44, 0x79, 0xf1, 0x93, 0x6b, 0x33,
0xd7, 0x74, 0xfe, 0xea, 0xe8, 0x5c, 0xaf, 0x16, 0xce, 0xe0, 0x04, 0x41, 0x15, 0x4e, 0xf6, 0x82,
0xa8, 0xc2, 0x29, 0x3c, 0x1d, 0x28, 0xd8, 0xf9, 0x63, 0x6c, 0x20, 0x62, 0x64, 0x43, 0x72, 0x7d,
0x66, 0xf9, 0x16, 0x5e, 0x6a, 0x9d, 0x0b, 0xa5, 0x9b, 0xc6, 0x5d, 0x83, 0x1c, 0x00, 0xe4, 0x82,
0x77, 0x41, 0x23, 0xcf, 0x60, 0x23, 0x67, 0xea, 0x84, 0xde, 0x3d, 0xc8, 0xbb, 0x06, 0x39, 0x02,
0xab, 0x78, 0xf6, 0x49, 0xb7, 0xa0, 0x5f, 0xb1, 0x5f, 0x3a, 0x37, 0xe6, 0xca, 0xb3, 0x3a, 0xae,
0x95, 0x8e, 0x2c, 0x99, 0xb2, 0x98, 0x59, 0x0c, 0x9d, 0xde, 0x7c, 0x85, 0x04, 0xf3, 0xe1, 0xfb,
0xbf, 0xbe, 0xee, 0x1a, 0xaf, 0x5e, 0x77, 0x8d, 0x3f, 0x5e, 0x77, 0x8d, 0x1f, 0xdf, 0x74, 0x6b,
0xaf, 0xde, 0x74, 0x6b, 0xbf, 0xbf, 0xe9, 0xd6, 0xbe, 0xec, 0xcc, 0xff, 0x07, 0xf1, 0x64, 0x59,
0xfd, 0xdc, 0xfb, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x01, 0x10, 0xe3, 0xc4, 0x45, 0x0e, 0x00, 0x00,
}
func (m *HeadSyncRange) Marshal() (dAtA []byte, err error) {
@ -1937,6 +1999,43 @@ func (m *HeadSyncResultElement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *EncodedHeadSyncResults) 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 *EncodedHeadSyncResults) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *EncodedHeadSyncResults) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Results) > 0 {
for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Results[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintSpacesync(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func (m *HeadSyncRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -2006,6 +2105,13 @@ func (m *HeadSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.EncodedResult) > 0 {
i -= len(m.EncodedResult)
copy(dAtA[i:], m.EncodedResult)
i = encodeVarintSpacesync(dAtA, i, uint64(len(m.EncodedResult)))
i--
dAtA[i] = 0x1a
}
if m.DiffType != 0 {
i = encodeVarintSpacesync(dAtA, i, uint64(m.DiffType))
i--
@ -2887,6 +2993,21 @@ func (m *HeadSyncResultElement) Size() (n int) {
return n
}
func (m *EncodedHeadSyncResults) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Results) > 0 {
for _, e := range m.Results {
l = e.Size()
n += 1 + l + sovSpacesync(uint64(l))
}
}
return n
}
func (m *HeadSyncRequest) Size() (n int) {
if m == nil {
return 0
@ -2924,6 +3045,10 @@ func (m *HeadSyncResponse) Size() (n int) {
if m.DiffType != 0 {
n += 1 + sovSpacesync(uint64(m.DiffType))
}
l = len(m.EncodedResult)
if l > 0 {
n += 1 + l + sovSpacesync(uint64(l))
}
return n
}
@ -3670,6 +3795,90 @@ func (m *HeadSyncResultElement) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *EncodedHeadSyncResults) 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: EncodedHeadSyncResults: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: EncodedHeadSyncResults: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Results", 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.Results = append(m.Results, &HeadSyncResult{})
if err := m.Results[len(m.Results)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
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 *HeadSyncRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -3887,6 +4096,40 @@ func (m *HeadSyncResponse) Unmarshal(dAtA []byte) error {
break
}
}
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field EncodedResult", 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.EncodedResult = append(m.EncodedResult[:0], dAtA[iNdEx:postIndex]...)
if m.EncodedResult == nil {
m.EncodedResult = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSpacesync(dAtA[iNdEx:])

1
go.mod
View file

@ -18,6 +18,7 @@ require (
github.com/cheggaaa/mb/v3 v3.0.2
github.com/gobwas/glob v0.2.3
github.com/goccy/go-graphviz v0.2.9
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db
github.com/google/uuid v1.6.0
github.com/hashicorp/yamux v0.1.2
github.com/huandu/skiplist v1.2.1

2
go.sum
View file

@ -96,6 +96,8 @@ github.com/goccy/go-graphviz v0.2.9/go.mod h1:hssjl/qbvUXGmloY81BwXt2nqoApKo7DFg
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w=
github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/gopacket v1.1.19 h1:ves8RnFZPGiFnTS0uPQStjwru6uO6h+nlr9j6fL7kF8=