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

Remove some old code

Browse source
This commit is contained in:
mcrakhman 2024-12-03 22:22:22 +01:00
parent 34fbb6baa8
commit f1754c89cd
No known key found for this signature in database
GPG key ID: DED12CFEF5B8396B
13 changed files with 15 additions and 923 deletions
Download patch file Download diff file Expand all files Collapse all files

79
commonspace/object/acl/liststorage/inmemory.go
View file

@ -1,79 +0,0 @@
package liststorage
import (
"context"
"fmt"
"sync"
"github.com/anyproto/any-sync/consensus/consensusproto"
)
type inMemoryAclListStorage struct {
id string
root *consensusproto.RawRecordWithId
head string
records map[string]*consensusproto.RawRecordWithId
sync.RWMutex
}
func NewInMemoryAclListStorage(
id string,
records []*consensusproto.RawRecordWithId) (ListStorage, error) {
allRecords := make(map[string]*consensusproto.RawRecordWithId)
for _, ch := range records {
allRecords[ch.Id] = ch
}
root := records[0]
head := records[len(records)-1]
return &inMemoryAclListStorage{
id: root.Id,
root: root,
head: head.Id,
records: allRecords,
}, nil
}
func (t *inMemoryAclListStorage) Id() string {
t.RLock()
defer t.RUnlock()
return t.id
}
func (t *inMemoryAclListStorage) Root() (*consensusproto.RawRecordWithId, error) {
t.RLock()
defer t.RUnlock()
return t.root, nil
}
func (t *inMemoryAclListStorage) Head() (string, error) {
t.RLock()
defer t.RUnlock()
return t.head, nil
}
func (t *inMemoryAclListStorage) SetHead(head string) error {
t.Lock()
defer t.Unlock()
t.head = head
return nil
}
func (t *inMemoryAclListStorage) AddRawRecord(ctx context.Context, record *consensusproto.RawRecordWithId) error {
t.Lock()
defer t.Unlock()
t.records[record.Id] = record
return nil
}
func (t *inMemoryAclListStorage) GetRawRecord(ctx context.Context, recordId string) (*consensusproto.RawRecordWithId, error) {
t.RLock()
defer t.RUnlock()
if res, exists := t.records[recordId]; exists {
return res, nil
}
return nil, fmt.Errorf("could not get record with id: %s", recordId)
}

29
commonspace/object/acl/liststorage/liststorage.go
View file

@ -1,29 +0,0 @@
//go:generate mockgen -destination mock_liststorage/mock_liststorage.go github.com/anyproto/any-sync/commonspace/object/acl/liststorage ListStorage
package liststorage
import (
"context"
"errors"
"github.com/anyproto/any-sync/consensus/consensusproto"
)
var (
ErrUnknownAclId = errors.New("acl does not exist")
ErrAclExists = errors.New("acl already exists")
ErrUnknownRecord = errors.New("record doesn't exist")
)
type Exporter interface {
ListStorage(root *consensusproto.RawRecordWithId) (ListStorage, error)
}
type ListStorage interface {
Id() string
Root() (*consensusproto.RawRecordWithId, error)
Head() (string, error)
SetHead(headId string) error
GetRawRecord(ctx context.Context, id string) (*consensusproto.RawRecordWithId, error)
AddRawRecord(ctx context.Context, rec *consensusproto.RawRecordWithId) error
}

129
commonspace/object/acl/liststorage/mock_liststorage/mock_liststorage.go
View file

@ -1,129 +0,0 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anyproto/any-sync/commonspace/object/acl/liststorage (interfaces: ListStorage)
//
// Generated by this command:
//
// mockgen -destination mock_liststorage/mock_liststorage.go github.com/anyproto/any-sync/commonspace/object/acl/liststorage ListStorage
//
// Package mock_liststorage is a generated GoMock package.
package mock_liststorage
import (
context "context"
reflect "reflect"
consensusproto "github.com/anyproto/any-sync/consensus/consensusproto"
gomock "go.uber.org/mock/gomock"
)
// MockListStorage is a mock of ListStorage interface.
type MockListStorage struct {
ctrl *gomock.Controller
recorder *MockListStorageMockRecorder
isgomock struct{}
}
// MockListStorageMockRecorder is the mock recorder for MockListStorage.
type MockListStorageMockRecorder struct {
mock *MockListStorage
}
// NewMockListStorage creates a new mock instance.
func NewMockListStorage(ctrl *gomock.Controller) *MockListStorage {
mock := &MockListStorage{ctrl: ctrl}
mock.recorder = &MockListStorageMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockListStorage) EXPECT() *MockListStorageMockRecorder {
return m.recorder
}
// AddRawRecord mocks base method.
func (m *MockListStorage) AddRawRecord(ctx context.Context, rec *consensusproto.RawRecordWithId) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawRecord", ctx, rec)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawRecord indicates an expected call of AddRawRecord.
func (mr *MockListStorageMockRecorder) AddRawRecord(ctx, rec any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockListStorage)(nil).AddRawRecord), ctx, rec)
}
// GetRawRecord mocks base method.
func (m *MockListStorage) GetRawRecord(ctx context.Context, id string) (*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetRawRecord", ctx, id)
ret0, _ := ret[0].(*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetRawRecord indicates an expected call of GetRawRecord.
func (mr *MockListStorageMockRecorder) GetRawRecord(ctx, id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawRecord", reflect.TypeOf((*MockListStorage)(nil).GetRawRecord), ctx, id)
}
// Head mocks base method.
func (m *MockListStorage) Head() (string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Head")
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Head indicates an expected call of Head.
func (mr *MockListStorageMockRecorder) Head() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockListStorage)(nil).Head))
}
// Id mocks base method.
func (m *MockListStorage) Id() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Id")
ret0, _ := ret[0].(string)
return ret0
}
// Id indicates an expected call of Id.
func (mr *MockListStorageMockRecorder) Id() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockListStorage)(nil).Id))
}
// Root mocks base method.
func (m *MockListStorage) Root() (*consensusproto.RawRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Root")
ret0, _ := ret[0].(*consensusproto.RawRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Root indicates an expected call of Root.
func (mr *MockListStorageMockRecorder) Root() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Root", reflect.TypeOf((*MockListStorage)(nil).Root))
}
// SetHead mocks base method.
func (m *MockListStorage) SetHead(headId string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHead", headId)
ret0, _ := ret[0].(error)
return ret0
}
// SetHead indicates an expected call of SetHead.
func (mr *MockListStorageMockRecorder) SetHead(headId any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHead", reflect.TypeOf((*MockListStorage)(nil).SetHead), headId)
}

88
commonspace/object/tree/exporter/treeexporter.go
View file

@ -1,88 +0,0 @@
package exporter
import (
"github.com/anyproto/any-sync/commonspace/object/acl/liststorage"
"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
"github.com/anyproto/any-sync/commonspace/object/tree/treestorage"
"github.com/anyproto/any-sync/util/crypto"
)
type DataConverter interface {
Unmarshall(dataType string, decrypted []byte) (any, error)
Marshall(model any) (data []byte, dataType string, err error)
}
type TreeExporterParams struct {
ListStorageExporter liststorage.Exporter
TreeStorageExporter treestorage.Exporter
DataConverter DataConverter
}
type TreeExporter interface {
ExportUnencrypted(tree objecttree.ReadableObjectTree) (err error)
}
type treeExporter struct {
listExporter liststorage.Exporter
treeExporter treestorage.Exporter
converter DataConverter
}
func NewTreeExporter(params TreeExporterParams) TreeExporter {
return &treeExporter{
listExporter: params.ListStorageExporter,
treeExporter: params.TreeStorageExporter,
converter: params.DataConverter,
}
}
func (t *treeExporter) ExportUnencrypted(tree objecttree.ReadableObjectTree) (err error) {
lst := tree.AclList()
// this exports root which should be enough before we implement acls
_, err = t.listExporter.ListStorage(lst.Root())
if err != nil {
return
}
treeStorage, err := t.treeExporter.TreeStorage(tree.Header())
if err != nil {
return
}
changeBuilder := objecttree.NewChangeBuilder(crypto.NewKeyStorage(), tree.Header())
putStorage := func(change *objecttree.Change) (err error) {
var raw *treechangeproto.RawTreeChangeWithId
raw, err = changeBuilder.Marshall(change)
if err != nil {
return
}
return treeStorage.AddRawChange(raw)
}
err = tree.IterateRoot(
func(change *objecttree.Change, decrypted []byte) (any, error) {
return t.converter.Unmarshall(change.DataType, decrypted)
},
func(change *objecttree.Change) bool {
if change.Id == tree.Id() {
err = putStorage(change)
return err == nil
}
var (
data []byte
dataType string
)
data, dataType, err = t.converter.Marshall(change.Model)
if err != nil {
return false
}
// that means that change is unencrypted
change.ReadKeyId = ""
change.Data = data
change.DataType = dataType
err = putStorage(change)
return err == nil
})
if err != nil {
return
}
return treeStorage.SetHeads(tree.Heads())
}

53
commonspace/object/tree/synctree/synchandler.go
View file

@ -11,7 +11,6 @@ import (
"github.com/anyproto/any-sync/commonspace/object/tree/objecttree"
response "github.com/anyproto/any-sync/commonspace/object/tree/synctree/response"
"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
"github.com/anyproto/any-sync/commonspace/spacesyncproto"
"github.com/anyproto/any-sync/commonspace/sync/objectsync/objectmessages"
"github.com/anyproto/any-sync/commonspace/sync/syncdeps"
"github.com/anyproto/any-sync/commonspace/syncstatus"
@ -85,58 +84,6 @@ func (s *syncHandler) HandleHeadUpdate(ctx context.Context, statusUpdater syncst
return nil, nil
}
func (s *syncHandler) HandleDeprecatedRequest(ctx context.Context, req *spacesyncproto.ObjectSyncMessage) (resp *spacesyncproto.ObjectSyncMessage, err error) {
unmarshalled := &treechangeproto.TreeSyncMessage{}
err = proto.Unmarshal(req.Payload, unmarshalled)
if err != nil {
return nil, err
}
cnt := unmarshalled.GetContent().GetFullSyncRequest()
if cnt == nil {
return nil, treechangeproto.ErrGetTree
}
peerId, err := peer.CtxPeerId(ctx)
if err != nil {
return nil, err
}
prepareResponse := func(chs []*treechangeproto.RawTreeChangeWithId) (*spacesyncproto.ObjectSyncMessage, error) {
treeSyncMessage := treechangeproto.WrapFullResponse(&treechangeproto.TreeFullSyncResponse{
Heads: s.tree.Heads(),
SnapshotPath: s.tree.SnapshotPath(),
Changes: chs,
}, s.tree.Header())
payload, err := proto.Marshal(treeSyncMessage)
if err != nil {
return nil, err
}
return &spacesyncproto.ObjectSyncMessage{
SpaceId: req.SpaceId,
Payload: payload,
ObjectId: req.ObjectId,
}, nil
}
s.tree.Lock()
defer s.tree.Unlock()
// in this case we are only adding data and returning empty response
if cnt.Changes != nil {
if !slice.UnsortedEquals(s.tree.Heads(), cnt.Heads) {
_, err = s.tree.AddRawChangesFromPeer(ctx, peerId, objecttree.RawChangesPayload{
NewHeads: cnt.Heads,
RawChanges: cnt.Changes,
})
if err != nil {
log.Warn("failed to add changes from peer", zap.Error(err), zap.String("peerId", peerId))
}
}
return prepareResponse(nil)
}
chs, err := s.tree.ChangesAfterCommonSnapshot(cnt.SnapshotPath, cnt.Heads)
if err != nil {
return nil, err
}
return prepareResponse(chs)
}
func (s *syncHandler) HandleStreamRequest(ctx context.Context, rq syncdeps.Request, updater syncdeps.QueueSizeUpdater, send func(resp proto.Message) error) (syncdeps.Request, error) {
req, ok := rq.(*objectmessages.Request)
if !ok {

113
commonspace/object/tree/synctree/synchandler_test.go
View file

@ -12,7 +12,6 @@ import (
"github.com/anyproto/any-sync/commonspace/object/tree/synctree/response"
"github.com/anyproto/any-sync/commonspace/object/tree/synctree/response/mock_response"
"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
"github.com/anyproto/any-sync/commonspace/spacesyncproto"
"github.com/anyproto/any-sync/commonspace/sync/objectsync/objectmessages"
"github.com/anyproto/any-sync/commonspace/syncstatus/mock_syncstatus"
"github.com/anyproto/any-sync/net/peer"
@ -28,18 +27,18 @@ func TestSyncHandler_HeadUpdate(t *testing.T) {
t.Run("head update ok, everything added, we don't send request", func(t *testing.T) {
fx := newSyncHandlerFixture(t)
defer fx.finish()
rawCh := &treechangeproto.RawTreeChangeWithId{
rawCh := objecttree.StorageChange{
RawChange: []byte("abcd"),
Id: "chId",
}
heads := []string{rawCh.Id}
changes := []*treechangeproto.RawTreeChangeWithId{rawCh}
changes := []*treechangeproto.RawTreeChangeWithId{rawCh.RawTreeChangeWithId()}
treeHeadUpdate := &treechangeproto.TreeHeadUpdate{
Changes: changes,
Heads: heads,
SnapshotPath: []string{rawCh.Id},
}
wrapped := treechangeproto.WrapHeadUpdate(treeHeadUpdate, rawCh)
wrapped := treechangeproto.WrapHeadUpdate(treeHeadUpdate, rawCh.RawTreeChangeWithId())
marshaled, err := wrapped.Marshal()
require.NoError(t, err)
headUpdate := &objectmessages.HeadUpdate{
@ -58,7 +57,7 @@ func TestSyncHandler_HeadUpdate(t *testing.T) {
}).Return(objecttree.AddResult{
OldHeads: []string{"head"},
Heads: heads,
Added: []*treechangeproto.RawTreeChangeWithId{rawCh},
Added: []objecttree.StorageChange{rawCh},
Mode: objecttree.Append,
}, nil)
req, err := fx.syncHandler.HandleHeadUpdate(ctx, fx.syncStatus, headUpdate)
@ -68,18 +67,18 @@ func TestSyncHandler_HeadUpdate(t *testing.T) {
t.Run("head update different heads after add, we send request", func(t *testing.T) {
fx := newSyncHandlerFixture(t)
defer fx.finish()
rawCh := &treechangeproto.RawTreeChangeWithId{
rawCh := objecttree.StorageChange{
RawChange: []byte("abcd"),
Id: "chId",
}
heads := []string{rawCh.Id}
changes := []*treechangeproto.RawTreeChangeWithId{rawCh}
changes := []*treechangeproto.RawTreeChangeWithId{rawCh.RawTreeChangeWithId()}
treeHeadUpdate := &treechangeproto.TreeHeadUpdate{
Changes: changes,
Heads: heads,
SnapshotPath: []string{rawCh.Id},
}
wrapped := treechangeproto.WrapHeadUpdate(treeHeadUpdate, rawCh)
wrapped := treechangeproto.WrapHeadUpdate(treeHeadUpdate, rawCh.RawTreeChangeWithId())
marshaled, err := wrapped.Marshal()
require.NoError(t, err)
headUpdate := &objectmessages.HeadUpdate{
@ -98,7 +97,7 @@ func TestSyncHandler_HeadUpdate(t *testing.T) {
}).Return(objecttree.AddResult{
OldHeads: []string{"head"},
Heads: []string{"other"},
Added: []*treechangeproto.RawTreeChangeWithId{rawCh},
Added: []objecttree.StorageChange{rawCh},
Mode: objecttree.Append,
}, nil)
returnReq := &objectmessages.Request{
@ -178,102 +177,6 @@ func TestSyncHandler_HeadUpdate(t *testing.T) {
})
}
func TestSyncHandler_HandleDeprecatedObjectSync(t *testing.T) {
t.Run("request with no changes, return non empty response", func(t *testing.T) {
fx := newSyncHandlerFixture(t)
defer fx.finish()
fullSyncReq := &treechangeproto.TreeFullSyncRequest{
Heads: []string{"head"},
SnapshotPath: []string{"root"},
}
rootCh := &treechangeproto.RawTreeChangeWithId{
Id: "objectId",
}
treeSyncMsg := treechangeproto.WrapFullRequest(fullSyncReq, rootCh)
payload, err := treeSyncMsg.Marshal()
require.NoError(t, err)
msg := &spacesyncproto.ObjectSyncMessage{
SpaceId: "spaceId",
Payload: payload,
ObjectId: "objectId",
}
fx.tree.EXPECT().ChangesAfterCommonSnapshot([]string{"root"}, []string{"head"}).Return([]*treechangeproto.RawTreeChangeWithId{rootCh}, nil)
fx.tree.EXPECT().Heads().Return([]string{"head"})
fx.tree.EXPECT().SnapshotPath().Return([]string{"root"})
fx.tree.EXPECT().Header().Return(rootCh)
ctx = peer.CtxWithPeerId(ctx, "peerId")
resp, err := fx.syncHandler.HandleDeprecatedRequest(ctx, msg)
require.NoError(t, err)
require.Equal(t, "objectId", resp.ObjectId)
require.Equal(t, "spaceId", resp.SpaceId)
})
t.Run("request with no changes, different heads, return empty response", func(t *testing.T) {
fx := newSyncHandlerFixture(t)
defer fx.finish()
rootCh := &treechangeproto.RawTreeChangeWithId{
Id: "objectId",
}
fullSyncReq := &treechangeproto.TreeFullSyncRequest{
Heads: []string{"head"},
SnapshotPath: []string{"root"},
Changes: []*treechangeproto.RawTreeChangeWithId{
rootCh,
},
}
treeSyncMsg := treechangeproto.WrapFullRequest(fullSyncReq, rootCh)
payload, err := treeSyncMsg.Marshal()
require.NoError(t, err)
msg := &spacesyncproto.ObjectSyncMessage{
SpaceId: "spaceId",
Payload: payload,
ObjectId: "objectId",
}
ctx = peer.CtxWithPeerId(ctx, "peerId")
fx.tree.EXPECT().Heads().Return([]string{"otherHead"})
fx.tree.EXPECT().AddRawChangesFromPeer(ctx, "peerId", objecttree.RawChangesPayload{
NewHeads: []string{"head"},
RawChanges: []*treechangeproto.RawTreeChangeWithId{rootCh},
})
fx.tree.EXPECT().Heads().Return([]string{"head"})
fx.tree.EXPECT().SnapshotPath().Return([]string{"root"})
fx.tree.EXPECT().Header().Return(rootCh)
resp, err := fx.syncHandler.HandleDeprecatedRequest(ctx, msg)
require.NoError(t, err)
require.Equal(t, "objectId", resp.ObjectId)
require.Equal(t, "spaceId", resp.SpaceId)
})
t.Run("request with no changes, same heads, return empty response", func(t *testing.T) {
fx := newSyncHandlerFixture(t)
defer fx.finish()
rootCh := &treechangeproto.RawTreeChangeWithId{
Id: "objectId",
}
fullSyncReq := &treechangeproto.TreeFullSyncRequest{
Heads: []string{"head"},
SnapshotPath: []string{"root"},
Changes: []*treechangeproto.RawTreeChangeWithId{
rootCh,
},
}
treeSyncMsg := treechangeproto.WrapFullRequest(fullSyncReq, rootCh)
payload, err := treeSyncMsg.Marshal()
require.NoError(t, err)
msg := &spacesyncproto.ObjectSyncMessage{
SpaceId: "spaceId",
Payload: payload,
ObjectId: "objectId",
}
ctx = peer.CtxWithPeerId(ctx, "peerId")
fx.tree.EXPECT().Heads().Times(2).Return([]string{"head"})
fx.tree.EXPECT().SnapshotPath().Return([]string{"root"})
fx.tree.EXPECT().Header().Return(rootCh)
resp, err := fx.syncHandler.HandleDeprecatedRequest(ctx, msg)
require.NoError(t, err)
require.Equal(t, "objectId", resp.ObjectId)
require.Equal(t, "spaceId", resp.SpaceId)
})
}
func TestSyncHandler_HandleStreamRequest(t *testing.T) {
t.Run("heads are different, we send request", func(t *testing.T) {
fx := newSyncHandlerFixture(t)

2
commonspace/object/tree/synctree/synctree.go
View file

@ -76,7 +76,7 @@ type BuildDeps struct {
Listener updatelistener.UpdateListener
AclList list.AclList
SpaceStorage spacestorage.SpaceStorage
TreeStorage treestorage.TreeStorage
TreeStorage objecttree.Storage
OnClose func(id string)
SyncStatus syncstatus.StatusUpdater
PeerGetter ResponsiblePeersGetter

11
commonspace/object/tree/synctree/synctree_test.go
View file

@ -54,11 +54,11 @@ func (s syncTreeMatcher) String() string {
}
type testTreeGetter struct {
treeStorage treestorage.TreeStorage
treeStorage objecttree.Storage
peerId string
}
func (t testTreeGetter) getTree(ctx context.Context) (treeStorage treestorage.TreeStorage, peerId string, err error) {
func (t testTreeGetter) getTree(ctx context.Context) (treeStorage objecttree.Storage, peerId string, err error) {
return t.treeStorage, t.peerId, nil
}
@ -89,7 +89,7 @@ func newFixture(t *testing.T) *fixture {
SyncClient: syncClient,
Listener: listener,
HeadNotifiable: headNotifiable,
BuildObjectTree: func(treestorage.TreeStorage, list.AclList) (objecttree.ObjectTree, error) {
BuildObjectTree: func(objecttree.Storage, list.AclList) (objecttree.ObjectTree, error) {
return objTree, nil
},
SyncStatus: syncStatus,
@ -208,10 +208,11 @@ func Test_SyncTree(t *testing.T) {
headUpdate := &objectmessages.HeadUpdate{}
t.Run("AddRawChangesFromPeer update", func(t *testing.T) {
changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
changes := []objecttree.StorageChange{{Id: "some"}}
rawChanges := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
payload := objecttree.RawChangesPayload{
NewHeads: []string{"headId1"},
RawChanges: changes,
RawChanges: rawChanges,
}
expectedRes := objecttree.AddResult{
Added: changes,

34
commonspace/object/tree/treestorage/helpers.go
View file

@ -1,34 +0,0 @@
package treestorage
import (
"bytes"
"strings"
)
func ParseHeads(headsPayload []byte) []string {
return strings.Split(string(headsPayload), "/")
}
func CreateHeadsPayload(heads []string) []byte {
return JoinStringsToBytes(heads...)
}
func JoinStringsToBytes(strs ...string) []byte {
var (
b bytes.Buffer
totalLen int
)
for _, s := range strs {
totalLen += len(s)
}
// adding separators
totalLen += len(strs) - 1
b.Grow(totalLen)
for idx, s := range strs {
if idx > 0 {
b.WriteString("/")
}
b.WriteString(s)
}
return b.Bytes()
}

171
commonspace/object/tree/treestorage/inmemory.go
View file

@ -1,171 +0,0 @@
package treestorage
import (
"context"
"fmt"
"sync"
"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
"github.com/anyproto/any-sync/util/slice"
)
type InMemoryTreeStorage struct {
id string
root *treechangeproto.RawTreeChangeWithId
heads []string
Changes map[string]*treechangeproto.RawTreeChangeWithId
addErr error
sync.Mutex
}
func (t *InMemoryTreeStorage) GetAllChangeIds() (chs []string, err error) {
t.Lock()
defer t.Unlock()
chs = make([]string, 0, len(t.Changes))
for id := range t.Changes {
chs = append(chs, id)
}
return
}
func (t *InMemoryTreeStorage) GetAppendRawChange(ctx context.Context, buf []byte, id string) (*treechangeproto.RawTreeChangeWithId, error) {
return t.GetRawChange(ctx, id)
}
func (t *InMemoryTreeStorage) SetReturnErrorOnAdd(err error) {
t.addErr = err
}
func (t *InMemoryTreeStorage) AddRawChangesSetHeads(changes []*treechangeproto.RawTreeChangeWithId, heads []string) error {
t.Lock()
defer t.Unlock()
if t.addErr != nil {
return t.addErr
}
for _, ch := range changes {
t.Changes[ch.Id] = ch
}
t.heads = append(t.heads[:0], heads...)
return nil
}
func NewInMemoryTreeStorage(
root *treechangeproto.RawTreeChangeWithId,
heads []string,
changes []*treechangeproto.RawTreeChangeWithId) (TreeStorage, error) {
allChanges := make(map[string]*treechangeproto.RawTreeChangeWithId)
for _, ch := range changes {
allChanges[ch.Id] = ch
}
allChanges[root.Id] = root
return &InMemoryTreeStorage{
id: root.Id,
root: root,
heads: append([]string(nil), heads...),
Changes: allChanges,
}, nil
}
func (t *InMemoryTreeStorage) HasChange(ctx context.Context, id string) (bool, error) {
_, exists := t.Changes[id]
return exists, nil
}
func (t *InMemoryTreeStorage) Id() string {
t.Lock()
defer t.Unlock()
return t.id
}
func (t *InMemoryTreeStorage) Root() (*treechangeproto.RawTreeChangeWithId, error) {
t.Lock()
defer t.Unlock()
return t.root, nil
}
func (t *InMemoryTreeStorage) Heads() ([]string, error) {
t.Lock()
defer t.Unlock()
return t.heads, nil
}
func (t *InMemoryTreeStorage) SetHeads(heads []string) error {
t.Lock()
defer t.Unlock()
t.heads = append(t.heads[:0], heads...)
return nil
}
func (t *InMemoryTreeStorage) AllChanges() []*treechangeproto.RawTreeChangeWithId {
var allChanges []*treechangeproto.RawTreeChangeWithId
for _, ch := range t.Changes {
allChanges = append(allChanges, ch)
}
return allChanges
}
func (t *InMemoryTreeStorage) AddRawChange(change *treechangeproto.RawTreeChangeWithId) error {
t.Lock()
defer t.Unlock()
// TODO: better to do deep copy
t.Changes[change.Id] = change
return nil
}
func (t *InMemoryTreeStorage) GetRawChange(ctx context.Context, changeId string) (*treechangeproto.RawTreeChangeWithId, error) {
t.Lock()
defer t.Unlock()
if res, exists := t.Changes[changeId]; exists {
return res, nil
}
return nil, fmt.Errorf("could not get change with id: %s", changeId)
}
func (t *InMemoryTreeStorage) Delete() error {
t.Lock()
defer t.Unlock()
t.root = nil
t.Changes = nil
t.heads = nil
return nil
}
func (t *InMemoryTreeStorage) Copy() *InMemoryTreeStorage {
t.Lock()
defer t.Unlock()
var changes []*treechangeproto.RawTreeChangeWithId
for _, ch := range t.Changes {
changes = append(changes, ch)
}
other, _ := NewInMemoryTreeStorage(t.root, t.heads, changes)
return other.(*InMemoryTreeStorage)
}
func (t *InMemoryTreeStorage) Remove(id string) {
t.Lock()
defer t.Unlock()
delete(t.Changes, id)
}
func (t *InMemoryTreeStorage) Equal(other *InMemoryTreeStorage) bool {
t.Lock()
defer t.Unlock()
if !slice.UnsortedEquals(t.heads, other.heads) {
return false
}
if len(t.Changes) != len(other.Changes) {
return false
}
for k, v := range t.Changes {
if otherV, exists := other.Changes[k]; exists {
if otherV.Id == v.Id {
continue
}
}
return false
}
return true
}

202
commonspace/object/tree/treestorage/mock_treestorage/mock_treestorage.go
View file

@ -1,202 +0,0 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anyproto/any-sync/commonspace/object/tree/treestorage (interfaces: TreeStorage)
//
// Generated by this command:
//
// mockgen -destination mock_treestorage/mock_treestorage.go github.com/anyproto/any-sync/commonspace/object/tree/treestorage TreeStorage
//
// Package mock_treestorage is a generated GoMock package.
package mock_treestorage
import (
context "context"
reflect "reflect"
treechangeproto "github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
gomock "go.uber.org/mock/gomock"
)
// MockTreeStorage is a mock of TreeStorage interface.
type MockTreeStorage struct {
ctrl *gomock.Controller
recorder *MockTreeStorageMockRecorder
isgomock struct{}
}
// MockTreeStorageMockRecorder is the mock recorder for MockTreeStorage.
type MockTreeStorageMockRecorder struct {
mock *MockTreeStorage
}
// NewMockTreeStorage creates a new mock instance.
func NewMockTreeStorage(ctrl *gomock.Controller) *MockTreeStorage {
mock := &MockTreeStorage{ctrl: ctrl}
mock.recorder = &MockTreeStorageMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTreeStorage) EXPECT() *MockTreeStorageMockRecorder {
return m.recorder
}
// AddRawChange mocks base method.
func (m *MockTreeStorage) AddRawChange(change *treechangeproto.RawTreeChangeWithId) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChange", change)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawChange indicates an expected call of AddRawChange.
func (mr *MockTreeStorageMockRecorder) AddRawChange(change any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChange", reflect.TypeOf((*MockTreeStorage)(nil).AddRawChange), change)
}
// AddRawChangesSetHeads mocks base method.
func (m *MockTreeStorage) AddRawChangesSetHeads(changes []*treechangeproto.RawTreeChangeWithId, heads []string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChangesSetHeads", changes, heads)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawChangesSetHeads indicates an expected call of AddRawChangesSetHeads.
func (mr *MockTreeStorageMockRecorder) AddRawChangesSetHeads(changes, heads any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawChangesSetHeads", reflect.TypeOf((*MockTreeStorage)(nil).AddRawChangesSetHeads), changes, heads)
}
// Delete mocks base method.
func (m *MockTreeStorage) Delete() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Delete")
ret0, _ := ret[0].(error)
return ret0
}
// Delete indicates an expected call of Delete.
func (mr *MockTreeStorageMockRecorder) Delete() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockTreeStorage)(nil).Delete))
}
// GetAllChangeIds mocks base method.
func (m *MockTreeStorage) GetAllChangeIds() ([]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAllChangeIds")
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetAllChangeIds indicates an expected call of GetAllChangeIds.
func (mr *MockTreeStorageMockRecorder) GetAllChangeIds() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllChangeIds", reflect.TypeOf((*MockTreeStorage)(nil).GetAllChangeIds))
}
// GetAppendRawChange mocks base method.
func (m *MockTreeStorage) GetAppendRawChange(ctx context.Context, buf []byte, id string) (*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetAppendRawChange", ctx, buf, id)
ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetAppendRawChange indicates an expected call of GetAppendRawChange.
func (mr *MockTreeStorageMockRecorder) GetAppendRawChange(ctx, buf, id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAppendRawChange", reflect.TypeOf((*MockTreeStorage)(nil).GetAppendRawChange), ctx, buf, id)
}
// GetRawChange mocks base method.
func (m *MockTreeStorage) GetRawChange(ctx context.Context, id string) (*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetRawChange", ctx, id)
ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetRawChange indicates an expected call of GetRawChange.
func (mr *MockTreeStorageMockRecorder) GetRawChange(ctx, id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawChange", reflect.TypeOf((*MockTreeStorage)(nil).GetRawChange), ctx, id)
}
// HasChange mocks base method.
func (m *MockTreeStorage) HasChange(ctx context.Context, id string) (bool, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HasChange", ctx, id)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// HasChange indicates an expected call of HasChange.
func (mr *MockTreeStorageMockRecorder) HasChange(ctx, id any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasChange", reflect.TypeOf((*MockTreeStorage)(nil).HasChange), ctx, id)
}
// Heads mocks base method.
func (m *MockTreeStorage) Heads() ([]string, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Heads")
ret0, _ := ret[0].([]string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Heads indicates an expected call of Heads.
func (mr *MockTreeStorageMockRecorder) Heads() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Heads", reflect.TypeOf((*MockTreeStorage)(nil).Heads))
}
// Id mocks base method.
func (m *MockTreeStorage) Id() string {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Id")
ret0, _ := ret[0].(string)
return ret0
}
// Id indicates an expected call of Id.
func (mr *MockTreeStorageMockRecorder) Id() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockTreeStorage)(nil).Id))
}
// Root mocks base method.
func (m *MockTreeStorage) Root() (*treechangeproto.RawTreeChangeWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Root")
ret0, _ := ret[0].(*treechangeproto.RawTreeChangeWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// Root indicates an expected call of Root.
func (mr *MockTreeStorageMockRecorder) Root() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Root", reflect.TypeOf((*MockTreeStorage)(nil).Root))
}
// SetHeads mocks base method.
func (m *MockTreeStorage) SetHeads(heads []string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHeads", heads)
ret0, _ := ret[0].(error)
return ret0
}
// SetHeads indicates an expected call of SetHeads.
func (mr *MockTreeStorageMockRecorder) SetHeads(heads any) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeads", reflect.TypeOf((*MockTreeStorage)(nil).SetHeads), heads)
}

24
commonspace/object/tree/treestorage/treestorage.go
View file

@ -2,7 +2,6 @@
package treestorage
import (
"context"
"errors"
"github.com/anyproto/any-sync/commonspace/object/tree/treechangeproto"
@ -10,8 +9,6 @@ import (
var (
ErrUnknownTreeId = errors.New("tree does not exist")
ErrTreeExists = errors.New("tree already exists")
ErrUnknownChange = errors.New("change doesn't exist")
)
type TreeStorageCreatePayload struct {
@ -19,24 +16,3 @@ type TreeStorageCreatePayload struct {
Changes []*treechangeproto.RawTreeChangeWithId
Heads []string
}
type Exporter interface {
TreeStorage(root *treechangeproto.RawTreeChangeWithId) (TreeStorage, error)
}
type TreeStorageCreatorFunc = func(payload TreeStorageCreatePayload) (TreeStorage, error)
type TreeStorage interface {
Id() string
Root() (*treechangeproto.RawTreeChangeWithId, error)
Heads() ([]string, error)
SetHeads(heads []string) error
AddRawChange(change *treechangeproto.RawTreeChangeWithId) error
AddRawChangesSetHeads(changes []*treechangeproto.RawTreeChangeWithId, heads []string) error
GetAllChangeIds() ([]string, error)
GetRawChange(ctx context.Context, id string) (*treechangeproto.RawTreeChangeWithId, error)
GetAppendRawChange(ctx context.Context, buf []byte, id string) (*treechangeproto.RawTreeChangeWithId, error)
HasChange(ctx context.Context, id string) (bool, error)
Delete() error
}

3
commonspace/sync/syncdeps/syncdeps.go
View file

@ -8,7 +8,6 @@ import (
"storj.io/drpc"
"github.com/anyproto/any-sync/app"
"github.com/anyproto/any-sync/commonspace/spacesyncproto"
"github.com/anyproto/any-sync/commonspace/syncstatus"
)
@ -26,7 +25,6 @@ type RequestSender interface {
type ObjectSyncHandler interface {
HandleHeadUpdate(ctx context.Context, statusUpdater syncstatus.StatusUpdater, headUpdate drpc.Message) (Request, error)
HandleStreamRequest(ctx context.Context, rq Request, updater QueueSizeUpdater, send func(resp proto.Message) error) (Request, error)
HandleDeprecatedRequest(ctx context.Context, req *spacesyncproto.ObjectSyncMessage) (resp *spacesyncproto.ObjectSyncMessage, err error)
HandleResponse(ctx context.Context, peerId, objectId string, resp Response) error
ResponseCollector() ResponseCollector
}
@ -39,7 +37,6 @@ type SyncHandler interface {
app.Component
HandleHeadUpdate(ctx context.Context, headUpdate drpc.Message) (Request, error)
HandleStreamRequest(ctx context.Context, rq Request, updater QueueSizeUpdater, sendResponse func(resp proto.Message) error) (Request, error)
HandleDeprecatedObjectSync(ctx context.Context, req *spacesyncproto.ObjectSyncMessage) (resp *spacesyncproto.ObjectSyncMessage, err error)
ApplyRequest(ctx context.Context, rq Request, requestSender RequestSender) error
SendStreamRequest(ctx context.Context, rq Request, receive func(stream drpc.Stream) error) (err error)
}