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

Update code to work with acl lists and new models

Browse source
This commit is contained in:
mcrakhman 2022-08-20 14:28:06 +02:00 • committed by Mikhail Iudin
parent 48a64edce7
commit 86118686ad
No known key found for this signature in database
GPG key ID: FAAAA8BAABDFF1C0
23 changed files with 1340 additions and 394 deletions
Download patch file Download diff file Expand all files Collapse all files

13
Makefile
View file

@ -18,22 +18,19 @@ protos-go:
# Uncomment if needed
@$(eval ROOT_PKG := pkg)
@$(eval GOGO_START := GOGO_NO_UNDERSCORE=1 GOGO_EXPORT_ONEOF_INTERFACE=1)
@$(eval P_TREE_STORAGE_PATH_PB := $(ROOT_PKG)/acl/treestorage/treepb)
@$(eval P_ACL_CHANGES_PATH_PB := $(ROOT_PKG)/acl/aclchanges/aclpb)
@$(eval P_PLAINTEXT_CHANGES_PATH_PB := $(ROOT_PKG)/acl/testutils/testchanges/testchangepb)
@$(eval P_SYNC_CHANGES_PATH_PB := syncproto)
@$(eval P_TEST_CHANGES_PATH_PB := $(ROOT_PKG)/acl/testutils/testchanges)
@$(eval P_TIMESTAMP := Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types)
@$(eval P_STRUCT := Mgoogle/protobuf/struct.proto=github.com/gogo/protobuf/types)
@$(eval P_ACL_CHANGES := M$(P_ACL_CHANGES_PATH_PB)/protos/aclchanges.proto=github.com/anytypeio/go-anytype-infrastructure-experiments/$(P_ACL_CHANGES_PATH_PB))
@$(eval P_TREE_CHANGES := M$(P_TREE_STORAGE_PATH_PB)/protos/tree.proto=github.com/anytypeio/go-anytype-infrastructure-experiments/$(P_TREE_STORAGE_PATH_PB))
# use if needed $(eval PKGMAP := $$(P_TIMESTAMP),$$(P_STRUCT))
$(GOGO_START) protoc --gogofaster_out=:. $(P_ACL_CHANGES_PATH_PB)/protos/*.proto; mv $(P_ACL_CHANGES_PATH_PB)/protos/*.go $(P_ACL_CHANGES_PATH_PB)
$(GOGO_START) protoc --gogofaster_out=:. $(P_TREE_STORAGE_PATH_PB)/protos/*.proto; mv $(P_TREE_STORAGE_PATH_PB)/protos/*.go $(P_TREE_STORAGE_PATH_PB)
$(eval PKGMAP := $$(P_ACL_CHANGES),$$(P_TREE_CHANGES))
$(GOGO_START) protoc --gogofaster_out=$(PKGMAP):. $(P_SYNC_CHANGES_PATH_PB)/proto/*.proto
$(GOGO_START) protoc --gogofaster_out=$(PKGMAP):. service/space/spacesync/protos/*.proto
$(GOGO_START) protoc --gogofaster_out=:. $(P_TEST_CHANGES_PATH_PB)/proto/*.proto
$(eval PKGMAP := $$(P_ACL_CHANGES))
$(GOGO_START) protoc --gogofaster_out=$(PKGMAP),plugins=grpc:. $(P_SYNC_CHANGES_PATH_PB)/proto/*.proto
build:
@$(eval FLAGS := $$(shell govvv -flags -pkg github.com/anytypeio/go-anytype-infrastructure-experiments/app))
go build -v -o bin/anytype-node -ldflags "$(FLAGS)" cmd/node/node.go
go build -o bin/anytype-node -ldflags "$(FLAGS)" cmd/node/node.go

12
pkg/acl/list/list.go
View file

@ -5,6 +5,7 @@ import (
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/account"
"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"
"sync"
)
@ -21,6 +22,7 @@ type ACLList interface {
Get(id string) (*Record, error)
Iterate(iterFunc IterFunc)
IterateFrom(startId string, iterFunc IterFunc)
Close() (err error)
}
type aclList struct {
@ -35,7 +37,7 @@ type aclList struct {
sync.RWMutex
}
func BuildACLListWithIdentity(acc *account.AccountData, storage Storage) (ACLList, error) {
func BuildACLListWithIdentity(acc *account.AccountData, storage storage.ListStorage) (ACLList, error) {
builder := newACLStateBuilderWithIdentity(acc.Decoder, acc)
header, err := storage.Header()
if err != nil {
@ -54,7 +56,7 @@ func BuildACLListWithIdentity(acc *account.AccountData, storage Storage) (ACLLis
records := []*Record{record}
for record.Content.PrevId != "" {
rawRecord, err = storage.GetRecord(context.Background(), record.Content.PrevId)
rawRecord, err = storage.GetRawRecord(context.Background(), record.Content.PrevId)
if err != nil {
return nil, err
}
@ -109,7 +111,7 @@ func (a *aclList) IsAfter(first string, second string) (bool, error) {
if !okFirst || !okSecond {
return false, fmt.Errorf("not all entries are there: first (%b), second (%b)", okFirst, okSecond)
}
return firstRec > secondRec, nil
return firstRec >= secondRec, nil
}
func (a *aclList) Head() *Record {
@ -143,3 +145,7 @@ func (a *aclList) IterateFrom(startId string, iterFunc IterFunc) {
}
}
}
func (a *aclList) Close() (err error) {
return nil
}

14
pkg/acl/list/storage.go
View file

@ -1,14 +0,0 @@
package list
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
)
type Storage interface {
ID() (string, error)
Head() (*aclpb.RawRecord, error)
Header() (*aclpb.Header, error)
GetRecord(ctx context.Context, id string) (*aclpb.RawRecord, error)
AddRecord(ctx context.Context, rec *aclpb.RawRecord) error
}

18
pkg/acl/treestorage/inmemory.go → pkg/acl/storage/inmemory.go
View file

@ -1,4 +1,4 @@
package treestorage
package storage
import (
"context"
@ -86,21 +86,21 @@ func (t *inMemoryTreeStorage) GetRawChange(ctx context.Context, changeId string)
return nil, fmt.Errorf("could not get change with id: %s", changeId)
}
type inMemoryTreeStorageProvider struct {
trees map[string]TreeStorage
type inMemoryStorageProvider struct {
objects map[string]Storage
sync.RWMutex
}
func (i *inMemoryTreeStorageProvider) TreeStorage(treeId string) (TreeStorage, error) {
func (i *inMemoryStorageProvider) Storage(id string) (Storage, error) {
i.RLock()
defer i.RUnlock()
if tree, exists := i.trees[treeId]; exists {
if tree, exists := i.objects[id]; exists {
return tree, nil
}
return nil, ErrUnknownTreeId
}
func (i *inMemoryTreeStorageProvider) CreateTreeStorage(treeId string, header *aclpb.Header, changes []*aclpb.RawChange) (TreeStorage, error) {
func (i *inMemoryStorageProvider) CreateTreeStorage(treeId string, header *aclpb.Header, changes []*aclpb.RawChange) (TreeStorage, error) {
i.Lock()
defer i.Unlock()
res, err := NewInMemoryTreeStorage(treeId, header, changes)
@ -108,12 +108,12 @@ func (i *inMemoryTreeStorageProvider) CreateTreeStorage(treeId string, header *a
return nil, err
}
i.trees[treeId] = res
i.objects[treeId] = res
return res, nil
}
func NewInMemoryTreeStorageProvider() Provider {
return &inMemoryTreeStorageProvider{
trees: make(map[string]TreeStorage),
return &inMemoryStorageProvider{
objects: make(map[string]Storage),
}
}

14
pkg/acl/storage/liststorage.go Normal file
View file

@ -0,0 +1,14 @@
package storage
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
)
type ListStorage interface {
Storage
Head() (*aclpb.RawRecord, error)
GetRawRecord(ctx context.Context, id string) (*aclpb.RawRecord, error)
AddRawRecord(ctx context.Context, rec *aclpb.RawRecord) error
}

4
pkg/acl/treestorage/provider.go → pkg/acl/storage/provider.go
View file

@ -1,4 +1,4 @@
package treestorage
package storage
import (
"errors"
@ -8,6 +8,6 @@ import (
var ErrUnknownTreeId = errors.New("tree does not exist")
type Provider interface {
TreeStorage(treeId string) (TreeStorage, error)
Storage(id string) (Storage, error)
CreateTreeStorage(treeId string, header *aclpb.Header, changes []*aclpb.RawChange) (TreeStorage, error)
}

8
pkg/acl/storage/storage.go Normal file
View file

@ -0,0 +1,8 @@
package storage
import "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
type Storage interface {
ID() (string, error)
Header() (*aclpb.Header, error)
}

6
pkg/acl/treestorage/storage.go → pkg/acl/storage/treestorage.go
View file

@ -1,4 +1,4 @@
package treestorage
package storage
import (
"context"
@ -6,9 +6,7 @@ import (
)
type TreeStorage interface {
ID() (string, error)
Header() (*aclpb.Header, error)
Storage
Heads() ([]string, error)
SetHeads(heads []string) error

1088
pkg/acl/testutils/testchanges/proto/test.pb.go Normal file
View file

File diff suppressed because it is too large Load diff

24
pkg/acl/testutils/testchanges/proto/test.proto Normal file
View file

@ -0,0 +1,24 @@
syntax = "proto3";
package anytype;
option go_package = "testchanges";
message PlainTextChange {
message Content {
oneof value {
TextAppend textAppend = 1;
}
}
message TextAppend {
string text = 1;
}
message Snapshot {
string text = 1;
}
message Data {
repeated Content content = 1;
Snapshot snapshot = 2;
}
}

4
pkg/acl/tree/commontree.go
View file

@ -2,7 +2,7 @@ package tree
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
)
type CommonTree interface {
@ -15,7 +15,7 @@ type CommonTree interface {
HasChange(string) bool
SnapshotPath() []string
ChangesAfterCommonSnapshot(snapshotPath []string) ([]*aclpb.RawChange, error)
Storage() treestorage.TreeStorage
Storage() storage.TreeStorage
DebugDump() (string, error)
Close() error
}

10
pkg/acl/tree/doctree.go
View file

@ -6,7 +6,7 @@ import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/cid"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/keys"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/keys/asymmetric/signingkey"
@ -56,7 +56,7 @@ type DocTree interface {
}
type docTree struct {
treeStorage treestorage.TreeStorage
treeStorage storage.TreeStorage
accountData *account.AccountData
updateListener TreeUpdateListener
@ -76,7 +76,7 @@ type docTree struct {
sync.RWMutex
}
func BuildDocTreeWithIdentity(t treestorage.TreeStorage, acc *account.AccountData, listener TreeUpdateListener, aclList list.ACLList) (DocTree, error) {
func BuildDocTreeWithIdentity(t storage.TreeStorage, acc *account.AccountData, listener TreeUpdateListener, aclList list.ACLList) (DocTree, error) {
treeBuilder := newTreeBuilder(t, acc.Decoder)
validator := newTreeValidator()
@ -112,7 +112,7 @@ func BuildDocTreeWithIdentity(t treestorage.TreeStorage, acc *account.AccountDat
return docTree, nil
}
func BuildDocTree(t treestorage.TreeStorage, decoder keys.Decoder, listener TreeUpdateListener, aclList list.ACLList) (DocTree, error) {
func BuildDocTree(t storage.TreeStorage, decoder keys.Decoder, listener TreeUpdateListener, aclList list.ACLList) (DocTree, error) {
treeBuilder := newTreeBuilder(t, decoder)
validator := newTreeValidator()
@ -182,7 +182,7 @@ func (d *docTree) Header() *aclpb.Header {
return d.header
}
func (d *docTree) Storage() treestorage.TreeStorage {
func (d *docTree) Storage() storage.TreeStorage {
return d.treeStorage
}

6
pkg/acl/tree/treebuilder.go
View file

@ -5,7 +5,7 @@ import (
"errors"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/keys"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/keys/asymmetric/signingkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/slice"
@ -23,10 +23,10 @@ type treeBuilder struct {
identityKeys map[string]signingkey.PubKey
signingPubKeyDecoder keys.Decoder
tree *Tree
treeStorage treestorage.TreeStorage
treeStorage storage.TreeStorage
}
func newTreeBuilder(t treestorage.TreeStorage, decoder keys.Decoder) *treeBuilder {
func newTreeBuilder(t storage.TreeStorage, decoder keys.Decoder) *treeBuilder {
return &treeBuilder{
signingPubKeyDecoder: decoder,
treeStorage: t,

6
pkg/acl/tree/treestorage.go
View file

@ -4,7 +4,7 @@ import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/cid"
"github.com/gogo/protobuf/proto"
"time"
@ -14,7 +14,7 @@ import (
//func CreateNewTreeStorageWithACL(
// acc *account.AccountData,
// build func(builder list.ACLChangeBuilder) error,
// create treestorage.CreatorFunc) (treestorage.TreeStorage, error) {
// create treestorage.CreatorFunc) (treestorage.Storage, error) {
// bld := list.newACLChangeBuilder()
// bld.Init(
// list.newACLStateWithIdentity(acc.Identity, acc.EncKey, signingkey.NewEd25519PubKeyDecoder()),
@ -56,7 +56,7 @@ func CreateNewTreeStorage(
acc *account.AccountData,
aclList list.ACLList,
content proto.Marshaler,
create treestorage.CreatorFunc) (treestorage.TreeStorage, error) {
create storage.CreatorFunc) (storage.TreeStorage, error) {
state := aclList.ACLState()
change := &aclpb.Change{

16
service/api/service.go
View file

@ -54,7 +54,6 @@ func (s *service) Run(ctx context.Context) (err error) {
mux := http.NewServeMux()
mux.HandleFunc("/treeDump", s.treeDump)
mux.HandleFunc("/createDocumentTree", s.createDocumentTree)
mux.HandleFunc("/createACLTree", s.createACLTree)
mux.HandleFunc("/appendDocument", s.appendDocument)
s.srv.Handler = mux
@ -99,21 +98,10 @@ func (s *service) createDocumentTree(w http.ResponseWriter, req *http.Request) {
var (
query = req.URL.Query()
text = query.Get("text")
aclTreeId = query.Get("aclTreeId")
aclListId = query.Get("aclListId")
)
timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*30)
treeId, err := s.documentService.CreateDocumentTree(timeoutCtx, aclTreeId, text)
cancel()
if err != nil {
sendText(w, http.StatusInternalServerError, err.Error())
return
}
sendText(w, http.StatusOK, treeId)
}
func (s *service) createACLTree(w http.ResponseWriter, req *http.Request) {
timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*30)
treeId, err := s.documentService.CreateACLTree(timeoutCtx)
treeId, err := s.documentService.CreateDocumentTree(timeoutCtx, aclListId, text)
cancel()
if err != nil {
sendText(w, http.StatusInternalServerError, err.Error())

97
service/document/service.go
View file

@ -7,9 +7,8 @@ import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/testutils/testchanges/testchangepb"
testchanges "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/testutils/testchanges/proto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/tree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage/treepb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/service/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/service/node"
"github.com/anytypeio/go-anytype-infrastructure-experiments/service/storage"
@ -35,7 +34,6 @@ type service struct {
type Service interface {
UpdateDocumentTree(ctx context.Context, id, text string) error
CreateACLTree(ctx context.Context) (id string, err error)
CreateDocumentTree(ctx context.Context, aclTreeId string, text string) (id string, err error)
}
@ -60,7 +58,7 @@ func (s *service) Name() (name string) {
}
func (s *service) Run(ctx context.Context) (err error) {
return nil
return s.importACLList(ctx)
}
func (s *service) Close(ctx context.Context) (err error) {
@ -70,7 +68,7 @@ func (s *service) Close(ctx context.Context) (err error) {
func (s *service) UpdateDocumentTree(ctx context.Context, id, text string) (err error) {
var (
ch *aclpb.RawChange
header *treepb.TreeHeader
header *aclpb.Header
snapshotPath []string
heads []string
)
@ -85,8 +83,8 @@ func (s *service) UpdateDocumentTree(ctx context.Context, id, text string) (err
docTree.Lock()
defer docTree.Unlock()
err = s.treeCache.Do(ctx, docTree.Header().AclTreeId, func(obj interface{}) error {
aclTree := obj.(tree.ACLTree)
err = s.treeCache.Do(ctx, docTree.Header().AclListId, func(obj interface{}) error {
aclTree := obj.(list.ACLList)
aclTree.RLock()
defer aclTree.RUnlock()
@ -123,69 +121,20 @@ func (s *service) UpdateDocumentTree(ctx context.Context, id, text string) (err
}, header, id))
}
func (s *service) CreateACLTree(ctx context.Context) (id string, err error) {
acc := s.account.Account()
var (
ch *aclpb.RawChange
header *treepb.TreeHeader
snapshotPath []string
heads []string
)
t, err := tree.CreateNewTreeStorageWithACL(acc, func(builder list.ACLChangeBuilder) error {
err := builder.UserAdd(acc.Identity, acc.EncKey.GetPublic(), aclpb.ACLChange_Admin)
if err != nil {
return err
}
// adding all predefined nodes to the document as admins
for _, n := range s.nodes {
err = builder.UserAdd(n.SigningKeyString, n.EncryptionKey, aclpb.ACLChange_Admin)
if err != nil {
return err
}
}
return nil
}, s.storage.CreateTreeStorage)
id, err = t.TreeID()
if err != nil {
return "", err
}
header, err = t.Header()
if err != nil {
return "", err
}
heads = []string{header.FirstChangeId}
snapshotPath = []string{header.FirstChangeId}
ch, err = t.GetChange(ctx, header.FirstChangeId)
if err != nil {
return "", err
}
if err != nil {
return "", err
}
err = s.messageService.SendToSpaceAsync("", syncproto.WrapHeadUpdate(&syncproto.SyncHeadUpdate{
Heads: heads,
Changes: []*aclpb.RawChange{ch},
SnapshotPath: snapshotPath,
}, header, id))
return id, nil
func (s *service) importACLList(ctx context.Context) (err error) {
panic("not implemented")
}
func (s *service) CreateDocumentTree(ctx context.Context, aclTreeId string, text string) (id string, err error) {
func (s *service) CreateDocumentTree(ctx context.Context, aclListId string, text string) (id string, err error) {
acc := s.account.Account()
var (
ch *aclpb.RawChange
header *treepb.TreeHeader
header *aclpb.Header
snapshotPath []string
heads []string
)
err = s.treeCache.Do(ctx, aclTreeId, func(obj interface{}) error {
t := obj.(tree.ACLTree)
err = s.treeCache.Do(ctx, aclListId, func(obj interface{}) error {
t := obj.(list.ACLList)
t.RLock()
defer t.RUnlock()
@ -205,9 +154,9 @@ func (s *service) CreateDocumentTree(ctx context.Context, aclTreeId string, text
return err
}
heads = []string{header.FirstChangeId}
snapshotPath = []string{header.FirstChangeId}
ch, err = doc.GetRawChange(ctx, header.FirstChangeId)
heads = []string{header.FirstId}
snapshotPath = []string{header.FirstId}
ch, err = doc.GetRawChange(ctx, header.FirstId)
if err != nil {
return err
}
@ -233,26 +182,26 @@ func (s *service) CreateDocumentTree(ctx context.Context, aclTreeId string, text
}
func createInitialTextChange(text string) proto.Marshaler {
return &testchangepb.PlainTextChangeData{
Content: []*testchangepb.PlainTextChangeContent{
return &testchanges.PlainTextChangeData{
Content: []*testchanges.PlainTextChangeContent{
createAppendTextChangeContent(text),
},
Snapshot: &testchangepb.PlainTextChangeSnapshot{Text: text},
Snapshot: &testchanges.PlainTextChangeSnapshot{Text: text},
}
}
func createAppendTextChange(text string) proto.Marshaler {
return &testchangepb.PlainTextChangeData{
Content: []*testchangepb.PlainTextChangeContent{
return &testchanges.PlainTextChangeData{
Content: []*testchanges.PlainTextChangeContent{
createAppendTextChangeContent(text),
},
}
}
func createAppendTextChangeContent(text string) *testchangepb.PlainTextChangeContent {
return &testchangepb.PlainTextChangeContent{
Value: &testchangepb.PlainTextChangeContentValueOfTextAppend{
TextAppend: &testchangepb.PlainTextChangeTextAppend{
func createAppendTextChangeContent(text string) *testchanges.PlainTextChangeContent {
return &testchanges.PlainTextChangeContent{
Value: &testchanges.PlainTextChangeContentValueOfTextAppend{
TextAppend: &testchanges.PlainTextChangeTextAppend{
Text: text,
},
},

15
service/storage/service.go
View file

@ -4,14 +4,13 @@ import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/app"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage/treepb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage"
)
var CName = "storage"
type Service interface {
treestorage.Provider
storage.Provider
}
func New() app.Component {
@ -19,19 +18,19 @@ func New() app.Component {
}
type service struct {
storageProvider treestorage.Provider
storageProvider storage.Provider
}
func (s *service) Init(ctx context.Context, a *app.App) (err error) {
s.storageProvider = treestorage.NewInMemoryTreeStorageProvider()
s.storageProvider = storage.NewInMemoryTreeStorageProvider()
return nil
}
func (s *service) TreeStorage(treeId string) (treestorage.TreeStorage, error) {
return s.storageProvider.TreeStorage(treeId)
func (s *service) Storage(treeId string) (storage.Storage, error) {
return s.storageProvider.Storage(treeId)
}
func (s *service) CreateTreeStorage(treeId string, header *treepb.TreeHeader, changes []*aclpb.RawChange) (treestorage.TreeStorage, error) {
func (s *service) CreateTreeStorage(treeId string, header *aclpb.Header, changes []*aclpb.RawChange) (storage.TreeStorage, error) {
return s.storageProvider.CreateTreeStorage(treeId, header, changes)
}

2
service/sync/message/service.go
View file

@ -119,6 +119,6 @@ func msgInfo(content *syncproto.Sync) (syncMethod string) {
case msg.GetHeadUpdate() != nil:
syncMethod = "HeadUpdate"
}
syncMethod = fmt.Sprintf("method: %s, treeType: %s", syncMethod, content.TreeHeader.Type.String())
syncMethod = fmt.Sprintf("method: %s, treeType: %s", syncMethod, content.TreeHeader.DocType.String())
return
}

227
service/sync/requesthandler/requesthandler.go
View file

@ -6,9 +6,9 @@ import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/app"
"github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list"
"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/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage/treepb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/service/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/service/treecache"
"github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto"
@ -77,7 +77,7 @@ func (r *requestHandler) HandleHeadUpdate(
ctx context.Context,
senderId string,
update *syncproto.SyncHeadUpdate,
header *treepb.TreeHeader,
header *aclpb.Header,
treeId string) (err error) {
var (
@ -88,81 +88,41 @@ func (r *requestHandler) HandleHeadUpdate(
log.With(zap.String("peerId", senderId), zap.String("treeId", treeId)).
Debug("processing head update")
updateACLTree := func() {
err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
t := obj.(tree.ACLTree)
t.Lock()
defer t.Unlock()
err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
docTree := obj.(tree.DocTree)
docTree.Lock()
defer docTree.Unlock()
if slice.UnsortedEquals(update.Heads, t.Heads()) {
return nil
}
if slice.UnsortedEquals(update.Heads, docTree.Heads()) {
return nil
}
return r.treeCache.Do(ctx, docTree.Header().AclListId, func(obj interface{}) error {
aclTree := obj.(list.ACLList)
aclTree.RLock()
defer aclTree.RUnlock()
// TODO: check if we already have those changes
result, err = t.AddRawChanges(ctx, update.Changes...)
result, err = docTree.AddRawChanges(ctx, aclTree, update.Changes...)
if err != nil {
return err
}
log.With(zap.Strings("update heads", update.Heads), zap.Strings("tree heads", t.Heads())).
log.With(zap.Strings("update heads", update.Heads), zap.Strings("tree heads", docTree.Heads())).
Debug("comparing heads after head update")
shouldFullSync := !slice.UnsortedEquals(update.Heads, t.Heads())
snapshotPath = t.SnapshotPath()
shouldFullSync := !slice.UnsortedEquals(update.Heads, docTree.Heads())
snapshotPath = docTree.SnapshotPath()
if shouldFullSync {
fullRequest, err = r.prepareFullSyncRequest(treeId, header, update.SnapshotPath, t)
fullRequest, err = r.prepareFullSyncRequest(update.SnapshotPath, docTree)
if err != nil {
return err
}
}
return nil
})
}
updateDocTree := func() {
err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
docTree := obj.(tree.DocTree)
docTree.Lock()
defer docTree.Unlock()
if slice.UnsortedEquals(update.Heads, docTree.Heads()) {
return nil
}
return r.treeCache.Do(ctx, docTree.Header().AclTreeId, func(obj interface{}) error {
aclTree := obj.(tree.ACLTree)
aclTree.RLock()
defer aclTree.RUnlock()
// TODO: check if we already have those changes
result, err = docTree.AddRawChanges(ctx, aclTree, update.Changes...)
if err != nil {
return err
}
log.With(zap.Strings("update heads", update.Heads), zap.Strings("tree heads", docTree.Heads())).
Debug("comparing heads after head update")
shouldFullSync := !slice.UnsortedEquals(update.Heads, docTree.Heads())
snapshotPath = docTree.SnapshotPath()
if shouldFullSync {
fullRequest, err = r.prepareFullSyncRequest(treeId, header, update.SnapshotPath, docTree)
if err != nil {
return err
}
}
return nil
})
})
}
switch header.Type {
case treepb.TreeHeader_ACLTree:
updateACLTree()
case treepb.TreeHeader_DocTree:
updateDocTree()
default:
return ErrIncorrectDocType
}
})
// if there are no such tree
if err == treestorage.ErrUnknownTreeId {
if err == storage.ErrUnknownTreeId {
// TODO: maybe we can optimize this by sending the header and stuff right away, so when the tree is created we are able to add it on first request
fullRequest = &syncproto.SyncFullRequest{}
}
@ -188,7 +148,7 @@ func (r *requestHandler) HandleFullSyncRequest(
ctx context.Context,
senderId string,
request *syncproto.SyncFullRequest,
header *treepb.TreeHeader,
header *aclpb.Header,
treeId string) (err error) {
var (
@ -199,74 +159,36 @@ func (r *requestHandler) HandleFullSyncRequest(
log.With(zap.String("peerId", senderId), zap.String("treeId", treeId)).
Debug("processing full sync request")
requestACLTree := func() {
err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
t := obj.(tree.ACLTree)
t.Lock()
defer t.Unlock()
//if slice.UnsortedEquals(request.Heads, t.Heads()) {
// return nil
//}
log.Info("getting doc tree from treeCache", zap.String("treeId", treeId))
err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
docTree := obj.(tree.DocTree)
docTree.Lock()
defer docTree.Unlock()
//if slice.UnsortedEquals(request.Heads, docTree.Heads()) {
// return nil
//}
log.Info("getting tree from treeCache", zap.String("aclId", docTree.Header().AclListId))
return r.treeCache.Do(ctx, docTree.Header().AclListId, func(obj interface{}) error {
aclTree := obj.(list.ACLList)
aclTree.RLock()
defer aclTree.RUnlock()
// TODO: check if we already have those changes
// if we have non-empty request
if len(request.Heads) != 0 {
result, err = t.AddRawChanges(ctx, request.Changes...)
result, err = docTree.AddRawChanges(ctx, aclTree, request.Changes...)
if err != nil {
return err
}
}
snapshotPath = t.SnapshotPath()
fullResponse, err = r.prepareFullSyncResponse(treeId, request.SnapshotPath, request.Changes, t)
snapshotPath = docTree.SnapshotPath()
fullResponse, err = r.prepareFullSyncResponse(treeId, request.SnapshotPath, request.Changes, docTree)
if err != nil {
return err
}
return nil
})
}
requestDocTree := func() {
log.Info("getting doc tree from treeCache", zap.String("treeId", treeId))
err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
docTree := obj.(tree.DocTree)
docTree.Lock()
defer docTree.Unlock()
//if slice.UnsortedEquals(request.Heads, docTree.Heads()) {
// return nil
//}
log.Info("getting tree from treeCache", zap.String("aclId", docTree.Header().AclTreeId))
return r.treeCache.Do(ctx, docTree.Header().AclTreeId, func(obj interface{}) error {
aclTree := obj.(tree.ACLTree)
aclTree.RLock()
defer aclTree.RUnlock()
// TODO: check if we already have those changes
// if we have non-empty request
if len(request.Heads) != 0 {
result, err = docTree.AddRawChanges(ctx, aclTree, request.Changes...)
if err != nil {
return err
}
}
snapshotPath = docTree.SnapshotPath()
fullResponse, err = r.prepareFullSyncResponse(treeId, request.SnapshotPath, request.Changes, docTree)
if err != nil {
return err
}
return nil
})
})
}
switch header.Type {
case treepb.TreeHeader_ACLTree:
requestACLTree()
case treepb.TreeHeader_DocTree:
requestDocTree()
default:
return ErrIncorrectDocType
}
})
if err != nil {
return err
@ -290,7 +212,7 @@ func (r *requestHandler) HandleFullSyncResponse(
ctx context.Context,
senderId string,
response *syncproto.SyncFullResponse,
header *treepb.TreeHeader,
header *aclpb.Header,
treeId string) (err error) {
var (
@ -300,66 +222,35 @@ func (r *requestHandler) HandleFullSyncResponse(
log.With(zap.String("peerId", senderId), zap.String("treeId", treeId)).
Debug("processing full sync response")
responseACLTree := func() {
err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
t := obj.(tree.ACLTree)
t.Lock()
defer t.Unlock()
err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
docTree := obj.(tree.DocTree)
docTree.Lock()
defer docTree.Unlock()
if slice.UnsortedEquals(response.Heads, t.Heads()) {
return nil
}
if slice.UnsortedEquals(response.Heads, docTree.Heads()) {
return nil
}
return r.treeCache.Do(ctx, docTree.Header().AclListId, func(obj interface{}) error {
aclTree := obj.(list.ACLList)
aclTree.RLock()
defer aclTree.RUnlock()
// TODO: check if we already have those changes
result, err = t.AddRawChanges(ctx, response.Changes...)
result, err = docTree.AddRawChanges(ctx, aclTree, response.Changes...)
if err != nil {
return err
}
snapshotPath = t.SnapshotPath()
snapshotPath = docTree.SnapshotPath()
return nil
})
}
responseDocTree := func() {
err = r.treeCache.Do(ctx, treeId, func(obj interface{}) error {
docTree := obj.(tree.DocTree)
docTree.Lock()
defer docTree.Unlock()
if slice.UnsortedEquals(response.Heads, docTree.Heads()) {
return nil
}
return r.treeCache.Do(ctx, docTree.Header().AclTreeId, func(obj interface{}) error {
aclTree := obj.(tree.ACLTree)
aclTree.RLock()
defer aclTree.RUnlock()
// TODO: check if we already have those changes
result, err = docTree.AddRawChanges(ctx, aclTree, response.Changes...)
if err != nil {
return err
}
snapshotPath = docTree.SnapshotPath()
return nil
})
})
}
switch header.Type {
case treepb.TreeHeader_ACLTree:
responseACLTree()
case treepb.TreeHeader_DocTree:
responseDocTree()
default:
return ErrIncorrectDocType
}
})
// if error or nothing has changed
if (err != nil || len(result.Added) == 0) && err != treestorage.ErrUnknownTreeId {
if (err != nil || len(result.Added) == 0) && err != storage.ErrUnknownTreeId {
return err
}
// if we have a new tree
if err == treestorage.ErrUnknownTreeId {
if err == storage.ErrUnknownTreeId {
err = r.createTree(ctx, response, header, treeId)
if err != nil {
return err
@ -379,7 +270,7 @@ func (r *requestHandler) HandleFullSyncResponse(
return r.messageService.SendToSpaceAsync("", syncproto.WrapHeadUpdate(newUpdate, header, treeId))
}
func (r *requestHandler) prepareFullSyncRequest(treeId string, header *treepb.TreeHeader, theirPath []string, t tree.CommonTree) (*syncproto.SyncFullRequest, error) {
func (r *requestHandler) prepareFullSyncRequest(theirPath []string, t tree.CommonTree) (*syncproto.SyncFullRequest, error) {
ourChanges, err := t.ChangesAfterCommonSnapshot(theirPath)
if err != nil {
return nil, err
@ -426,7 +317,7 @@ func (r *requestHandler) prepareFullSyncResponse(
func (r *requestHandler) createTree(
ctx context.Context,
response *syncproto.SyncFullResponse,
header *treepb.TreeHeader,
header *aclpb.Header,
treeId string) error {
return r.treeCache.Add(

23
service/treecache/service.go
View file

@ -7,6 +7,7 @@ import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/list"
aclstorage "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/ocache"
"github.com/anytypeio/go-anytype-infrastructure-experiments/service/account"
@ -17,13 +18,13 @@ import (
const CName = "treecache"
// TODO: add context
type TreeFunc = func(tree interface{}) error
type ObjFunc = func(obj interface{}) error
var log = logger.NewNamed("treecache")
type Service interface {
Do(ctx context.Context, treeId string, f TreeFunc) error
Add(ctx context.Context, treeId string, header *aclpb.Header, changes []*aclpb.RawChange, f TreeFunc) error
Do(ctx context.Context, treeId string, f ObjFunc) error
Add(ctx context.Context, treeId string, header *aclpb.Header, changes []*aclpb.RawChange, f ObjFunc) error
}
type service struct {
@ -36,7 +37,7 @@ func New() app.ComponentRunnable {
return &service{}
}
func (s *service) Do(ctx context.Context, treeId string, f TreeFunc) error {
func (s *service) Do(ctx context.Context, treeId string, f ObjFunc) error {
log.
With(zap.String("treeId", treeId)).
Debug("requesting tree from cache to perform operation")
@ -49,7 +50,7 @@ func (s *service) Do(ctx context.Context, treeId string, f TreeFunc) error {
return f(t)
}
func (s *service) Add(ctx context.Context, treeId string, header *treepb.TreeHeader, changes []*aclpb.RawChange, f TreeFunc) error {
func (s *service) Add(ctx context.Context, treeId string, header *aclpb.Header, changes []*aclpb.RawChange, f ObjFunc) error {
log.
With(zap.String("treeId", treeId), zap.Int("len(changes)", len(changes))).
Debug("adding tree with changes")
@ -82,7 +83,7 @@ func (s *service) Close(ctx context.Context) (err error) {
}
func (s *service) loadTree(ctx context.Context, id string) (ocache.Object, error) {
t, err := s.storage.TreeStorage(id)
t, err := s.storage.Storage(id)
if err != nil {
return nil, err
}
@ -93,7 +94,7 @@ func (s *service) loadTree(ctx context.Context, id string) (ocache.Object, error
switch header.DocType {
case aclpb.Header_ACL:
return list.BuildACLListWithIdentity(acc)
return list.BuildACLListWithIdentity(s.account.Account(), t.(aclstorage.ListStorage))
case aclpb.Header_DocTree:
break
default:
@ -101,13 +102,13 @@ func (s *service) loadTree(ctx context.Context, id string) (ocache.Object, error
}
log.Info("got header", zap.String("header", header.String()))
var docTree tree.DocTree
// TODO: it is a question if we need to use ACLTree on the first tree build, because we can think that the tree is already validated
err = s.Do(ctx, header.AclTreeId, func(obj interface{}) error {
aclTree := obj.(tree.ACLTree)
// TODO: it is a question if we need to use ACLList on the first tree build, because we can think that the tree is already validated
err = s.Do(ctx, header.AclListId, func(obj interface{}) error {
aclTree := obj.(list.ACLList)
aclTree.RLock()
defer aclTree.RUnlock()
docTree, err = tree.BuildDocTreeWithIdentity(t, s.account.Account(), nil, aclTree)
docTree, err = tree.BuildDocTreeWithIdentity(t.(aclstorage.TreeStorage), s.account.Account(), nil, aclTree)
if err != nil {
return err
}

2
syncproto/helpers.go
View file

@ -1,6 +1,6 @@
package syncproto
import "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage/treepb"
import "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/storage/treepb"
func WrapHeadUpdate(update *SyncHeadUpdate, header *treepb.TreeHeader, treeId string) *Sync {
return &Sync{

3
syncproto/proto/sync.proto
View file

@ -3,7 +3,6 @@ package anytype;
option go_package = "/syncproto";
import "pkg/acl/aclchanges/aclpb/protos/aclchanges.proto";
import "pkg/acl/treestorage/treepb/protos/tree.proto";
message Message {
Header header = 1;
@ -53,7 +52,7 @@ message System {
message Sync {
string spaceId = 1;
ContentValue message = 2;
tree.TreeHeader treeHeader = 3;
acl.Header treeHeader = 3;
string treeId = 4;
message ContentValue {

122
syncproto/sync.pb.go
View file

@ -6,7 +6,6 @@ package syncproto
import (
fmt "fmt"
aclpb "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/aclchanges/aclpb"
treepb "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/acl/treestorage/treepb"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
@ -590,10 +589,10 @@ func (m *SubscriptionUnsubscribeSpace) GetSpaceId() string {
}
type Sync struct {
SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
Message *SyncContentValue `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
TreeHeader *treepb.TreeHeader `protobuf:"bytes,3,opt,name=treeHeader,proto3" json:"treeHeader,omitempty"`
TreeId string `protobuf:"bytes,4,opt,name=treeId,proto3" json:"treeId,omitempty"`
SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
Message *SyncContentValue `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
TreeHeader *aclpb.Header `protobuf:"bytes,3,opt,name=treeHeader,proto3" json:"treeHeader,omitempty"`
TreeId string `protobuf:"bytes,4,opt,name=treeId,proto3" json:"treeId,omitempty"`
}
func (m *Sync) Reset() { *m = Sync{} }
@ -643,7 +642,7 @@ func (m *Sync) GetMessage() *SyncContentValue {
return nil
}
func (m *Sync) GetTreeHeader() *treepb.TreeHeader {
func (m *Sync) GetTreeHeader() *aclpb.Header {
if m != nil {
return m.TreeHeader
}
@ -996,61 +995,60 @@ func init() {
func init() { proto.RegisterFile("syncproto/proto/sync.proto", fileDescriptor_4b28dfdd48a89166) }
var fileDescriptor_4b28dfdd48a89166 = []byte{
// 858 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xd1, 0x8e, 0xda, 0x46,
0x14, 0xc5, 0x60, 0x20, 0x5c, 0x10, 0xeb, 0x4e, 0x92, 0xd6, 0x75, 0x22, 0x84, 0x50, 0xda, 0x5a,
0x69, 0xe4, 0x8d, 0x68, 0xa3, 0x4a, 0x7d, 0x4b, 0xb6, 0xbb, 0x02, 0x35, 0x05, 0x34, 0xc0, 0x56,
0xea, 0x4b, 0x34, 0xd8, 0x13, 0x40, 0x78, 0xc7, 0xae, 0xc7, 0x6e, 0xcb, 0x2f, 0xf4, 0x29, 0xdf,
0xd0, 0x6f, 0xe8, 0x47, 0xf4, 0x31, 0x8f, 0x7d, 0xac, 0x76, 0xd5, 0x7e, 0x47, 0x35, 0x33, 0x36,
0xf6, 0x3a, 0xe4, 0x35, 0x0f, 0xc0, 0xdc, 0x33, 0xe7, 0xdc, 0x7b, 0x2e, 0xe3, 0xb9, 0x06, 0x8b,
0xef, 0x99, 0x1b, 0x46, 0x41, 0x1c, 0x9c, 0xaa, 0x6f, 0x11, 0x3b, 0x72, 0x89, 0x9a, 0x84, 0xed,
0xe3, 0x7d, 0x48, 0xad, 0xa7, 0xe1, 0x6e, 0x7d, 0x4a, 0x5c, 0x5f, 0x7c, 0xdc, 0x0d, 0x61, 0x6b,
0xca, 0xc5, 0x32, 0x5c, 0x29, 0x0d, 0x2f, 0xe0, 0x4a, 0x6a, 0x3d, 0xc9, 0x14, 0x71, 0x44, 0x29,
0x8f, 0x83, 0x88, 0xac, 0xa9, 0x5c, 0xe7, 0x1a, 0x11, 0x29, 0xf6, 0xe0, 0x02, 0x9a, 0x3f, 0x50,
0xce, 0xc9, 0x9a, 0xa2, 0x2f, 0xa0, 0xb1, 0xa1, 0xc4, 0xa3, 0x91, 0xa9, 0xf5, 0x35, 0xbb, 0x3d,
0x3c, 0x71, 0x52, 0x13, 0xce, 0x48, 0xc2, 0x38, 0xdd, 0x46, 0x08, 0x74, 0x8f, 0xc4, 0xc4, 0xac,
0xf6, 0x35, 0xbb, 0x83, 0xe5, 0x7a, 0xf0, 0x87, 0x06, 0x0d, 0x45, 0x43, 0x26, 0x34, 0xe3, 0x88,
0xb8, 0x74, 0xec, 0xc9, 0x44, 0x1d, 0x9c, 0x85, 0xe8, 0x21, 0xb4, 0x22, 0xfa, 0x73, 0x42, 0x79,
0x3c, 0xf6, 0xa4, 0x5a, 0xc7, 0x39, 0x20, 0x74, 0x11, 0x0d, 0xfd, 0xfd, 0xd8, 0x33, 0x6b, 0x72,
0x2f, 0x0b, 0x91, 0x0d, 0xba, 0xf0, 0x61, 0xea, 0x7d, 0xcd, 0xee, 0x0e, 0xef, 0x1d, 0x7c, 0xa5,
0xce, 0x17, 0xfb, 0x90, 0x62, 0xc9, 0x10, 0x15, 0x3c, 0xba, 0x4a, 0xd6, 0x63, 0xf6, 0x3a, 0x30,
0xeb, 0x7d, 0xcd, 0x6e, 0xe1, 0x1c, 0x18, 0xfc, 0x59, 0x83, 0xc6, 0x7c, 0xcf, 0x63, 0x7a, 0x85,
0xbe, 0x81, 0xd6, 0x86, 0x30, 0x8f, 0x6f, 0xc8, 0x8e, 0xa6, 0xfd, 0x7e, 0x7a, 0xc8, 0xab, 0x38,
0xce, 0x28, 0x23, 0xe0, 0x9c, 0x2b, 0xbc, 0x84, 0x5b, 0xb6, 0x96, 0xf6, 0xdb, 0x05, 0x2f, 0xa9,
0x66, 0xb6, 0x65, 0x6b, 0x2c, 0x19, 0xe8, 0x33, 0xa8, 0x11, 0x77, 0x27, 0x7b, 0x69, 0x0f, 0xef,
0x96, 0x89, 0xcf, 0xdd, 0x1d, 0x16, 0xfb, 0xd6, 0x33, 0x68, 0x8d, 0x0a, 0xd9, 0x4f, 0xe4, 0xb9,
0xb8, 0x81, 0x7f, 0x49, 0x23, 0xbe, 0x0d, 0x98, 0x34, 0xd7, 0xc2, 0x65, 0xd8, 0x1a, 0x80, 0x2e,
0x6a, 0x21, 0x0b, 0xee, 0x24, 0x6c, 0xfb, 0xdb, 0x62, 0x7b, 0xa5, 0xfa, 0xd0, 0xf1, 0x21, 0xb6,
0x86, 0x50, 0x7b, 0xee, 0xee, 0xd0, 0x97, 0x50, 0xa7, 0x51, 0x14, 0x44, 0xa9, 0xe7, 0xfb, 0x65,
0x2b, 0xe7, 0x62, 0x13, 0x2b, 0x8e, 0xf5, 0x46, 0x83, 0xba, 0x04, 0x90, 0x03, 0xba, 0x1b, 0x78,
0x2a, 0x6b, 0x77, 0x68, 0x1d, 0x55, 0x39, 0x67, 0x81, 0x47, 0xb1, 0xe4, 0xa1, 0x3e, 0xb4, 0x3d,
0xca, 0xdd, 0x68, 0x1b, 0xc6, 0xc2, 0x77, 0x55, 0xfa, 0x2e, 0x42, 0x83, 0x67, 0xa0, 0x0b, 0x3e,
0x6a, 0x43, 0x73, 0x39, 0xf9, 0x7e, 0x32, 0xfd, 0x71, 0x62, 0x54, 0x50, 0x1f, 0x1e, 0x2e, 0x27,
0xf3, 0xe5, 0x6c, 0x36, 0xc5, 0x8b, 0xf3, 0xef, 0x5e, 0xcd, 0xf0, 0x74, 0x31, 0x3d, 0x9b, 0xbe,
0x7c, 0x75, 0x79, 0x8e, 0xe7, 0xe3, 0xe9, 0xc4, 0x80, 0xc1, 0xef, 0x55, 0xe8, 0xcc, 0x93, 0xd5,
0x21, 0x0f, 0x7a, 0x09, 0x5d, 0xae, 0xe2, 0x15, 0x9d, 0x87, 0xc4, 0xcd, 0x4e, 0xf0, 0x51, 0xee,
0xb1, 0x40, 0xcf, 0x82, 0x94, 0x8b, 0x4b, 0x5a, 0x84, 0xc1, 0x48, 0x58, 0x29, 0x9f, 0xfa, 0xa7,
0x3e, 0x3f, 0x9e, 0x6f, 0x59, 0x62, 0xe3, 0x77, 0xf4, 0xd6, 0x63, 0xe8, 0xde, 0xae, 0x2a, 0x9e,
0x6e, 0x1e, 0xe6, 0xb7, 0xa2, 0x85, 0xb3, 0xd0, 0x7a, 0x02, 0x46, 0x39, 0xe3, 0xfb, 0xd9, 0x83,
0x9b, 0x3a, 0xe8, 0xf3, 0x3d, 0x73, 0xdf, 0x4f, 0x41, 0x5f, 0x43, 0xf3, 0x4a, 0xdd, 0x8c, 0xb4,
0x8f, 0xe2, 0xd9, 0x31, 0xd7, 0x39, 0x0b, 0x58, 0x4c, 0x59, 0x7c, 0x49, 0xfc, 0x84, 0xe2, 0x8c,
0x8a, 0x9e, 0x02, 0x88, 0xb9, 0xa0, 0x2e, 0x71, 0xfa, 0xd4, 0x1a, 0x8e, 0x1c, 0x15, 0x8b, 0x03,
0x8e, 0x0b, 0x1c, 0xf4, 0x31, 0x34, 0x44, 0x34, 0xf6, 0xe4, 0xc5, 0x6c, 0xe1, 0x34, 0xb2, 0xfe,
0xd3, 0xa0, 0x53, 0xac, 0x81, 0xbe, 0x05, 0x10, 0xa3, 0x63, 0x19, 0x7a, 0x24, 0xce, 0xce, 0xca,
0xbc, 0xed, 0x69, 0x74, 0xd8, 0x1f, 0x55, 0x70, 0x81, 0x8d, 0x2e, 0xe0, 0xe4, 0x75, 0xe2, 0xfb,
0x82, 0x84, 0xd5, 0xa8, 0x38, 0xde, 0xd4, 0x45, 0xe2, 0xfb, 0x4e, 0xca, 0x18, 0x55, 0x70, 0x59,
0x84, 0xc6, 0x60, 0xe4, 0x10, 0x0f, 0x03, 0xc6, 0x69, 0xda, 0xe4, 0x83, 0xa3, 0x89, 0x14, 0x65,
0x54, 0xc1, 0xef, 0xc8, 0x5e, 0x34, 0xa1, 0xfe, 0x8b, 0xe8, 0xcb, 0x0a, 0x01, 0x72, 0xdf, 0xe8,
0x1e, 0xd4, 0x85, 0x6f, 0x6e, 0x6a, 0xfd, 0x9a, 0xdd, 0xc2, 0x2a, 0x40, 0x36, 0x34, 0xd3, 0xf9,
0x6c, 0x56, 0xfb, 0x35, 0xbb, 0x3d, 0xec, 0x3a, 0xc4, 0xf5, 0x1d, 0x4c, 0x7e, 0x3d, 0x93, 0x30,
0xce, 0xb6, 0xd1, 0x00, 0x3a, 0x9c, 0x91, 0x90, 0x6f, 0x82, 0x78, 0x46, 0xe2, 0x8d, 0x59, 0x93,
0x69, 0x6e, 0x61, 0xd6, 0xbf, 0x1a, 0xe8, 0xc2, 0xa0, 0x75, 0x05, 0xcd, 0xac, 0xb3, 0x0f, 0x51,
0x97, 0xc1, 0x9d, 0xac, 0xfd, 0x0f, 0x51, 0xef, 0xf1, 0x25, 0xb4, 0x0b, 0xc3, 0x1d, 0xdd, 0x87,
0x8f, 0x0a, 0xa1, 0x1a, 0x40, 0x46, 0x05, 0x3d, 0x80, 0x4f, 0x8a, 0x70, 0xe1, 0x8e, 0x1a, 0x1a,
0xba, 0x0b, 0x27, 0xb7, 0x34, 0xcc, 0x35, 0xaa, 0x2f, 0x1e, 0xfd, 0x75, 0xdd, 0xd3, 0xde, 0x5e,
0xf7, 0xb4, 0x7f, 0xae, 0x7b, 0xda, 0x9b, 0x9b, 0x5e, 0xe5, 0xed, 0x4d, 0xaf, 0xf2, 0xf7, 0x4d,
0xaf, 0xf2, 0x13, 0x9c, 0x1e, 0x5e, 0xc7, 0xab, 0x86, 0xfc, 0xf9, 0xea, 0xff, 0x00, 0x00, 0x00,
0xff, 0xff, 0x6a, 0x04, 0xc0, 0x87, 0xa2, 0x07, 0x00, 0x00,
// 840 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xd1, 0x8e, 0xdb, 0x44,
0x14, 0x8d, 0x13, 0x27, 0x69, 0x6e, 0xa2, 0xac, 0x99, 0xb6, 0x60, 0xdc, 0x2a, 0xb2, 0xac, 0x02,
0x56, 0x8b, 0xbc, 0x28, 0x50, 0x21, 0xf1, 0xd6, 0x2e, 0xbb, 0x4a, 0x44, 0x49, 0xa2, 0xc9, 0x66,
0x91, 0x78, 0xa9, 0x26, 0xf6, 0x34, 0x89, 0xe2, 0x1d, 0x1b, 0x8f, 0x0d, 0xe4, 0x17, 0x78, 0xea,
0x37, 0xf0, 0x0d, 0x7c, 0x04, 0x8f, 0x7d, 0xe4, 0x09, 0xa1, 0x5d, 0xc1, 0x77, 0xa0, 0x99, 0xb1,
0x13, 0xaf, 0xbb, 0x7d, 0xed, 0x43, 0x92, 0xb9, 0xf7, 0x9e, 0x73, 0xe6, 0x5c, 0x8f, 0xef, 0x04,
0x2c, 0xbe, 0x63, 0x7e, 0x9c, 0x44, 0x69, 0x74, 0xac, 0xbe, 0x45, 0xec, 0xc9, 0x25, 0x6a, 0x13,
0xb6, 0x4b, 0x77, 0x31, 0xb5, 0xbe, 0x88, 0xb7, 0xab, 0x63, 0xe2, 0x87, 0xe2, 0xe3, 0xaf, 0x09,
0x5b, 0x51, 0x2e, 0x96, 0xf1, 0x52, 0x71, 0x78, 0x29, 0xaf, 0xa8, 0xce, 0x19, 0xb4, 0xbf, 0xa7,
0x9c, 0x93, 0x15, 0x45, 0x9f, 0x41, 0x6b, 0x4d, 0x49, 0x40, 0x13, 0x53, 0xb3, 0x35, 0xb7, 0x3b,
0x3c, 0xf2, 0x72, 0x59, 0x6f, 0x24, 0xd3, 0x38, 0x2f, 0x23, 0x04, 0x7a, 0x40, 0x52, 0x62, 0xd6,
0x6d, 0xcd, 0xed, 0x61, 0xb9, 0x76, 0x7e, 0xd7, 0xa0, 0xa5, 0x60, 0xc8, 0x84, 0x76, 0x9a, 0x10,
0x9f, 0x8e, 0x03, 0x29, 0xd4, 0xc3, 0x45, 0x88, 0x1e, 0x42, 0x27, 0xa1, 0x3f, 0x65, 0x94, 0xa7,
0xe3, 0x40, 0xb2, 0x75, 0x7c, 0x48, 0x08, 0x5e, 0x42, 0xe3, 0x70, 0x37, 0x0e, 0xcc, 0x86, 0xac,
0x15, 0x21, 0x72, 0x41, 0x17, 0x3e, 0x4c, 0xdd, 0xd6, 0xdc, 0xfe, 0xf0, 0xde, 0xde, 0x57, 0xee,
0xfc, 0x7c, 0x17, 0x53, 0x2c, 0x11, 0x62, 0x87, 0x80, 0x2e, 0xb3, 0xd5, 0x98, 0xbd, 0x8a, 0xcc,
0xa6, 0xad, 0xb9, 0x1d, 0x7c, 0x48, 0x38, 0x7f, 0x34, 0xa0, 0x35, 0xdf, 0xf1, 0x94, 0x5e, 0xa2,
0xaf, 0xa1, 0xb3, 0x26, 0x2c, 0xe0, 0x6b, 0xb2, 0xa5, 0x79, 0xbf, 0x1f, 0xef, 0x75, 0x15, 0xc6,
0x1b, 0x15, 0x00, 0x7c, 0xc0, 0x0a, 0x2f, 0xf1, 0x86, 0xad, 0xa4, 0xfd, 0x6e, 0xc9, 0x4b, 0xce,
0x99, 0x6d, 0xd8, 0x0a, 0x4b, 0x04, 0xfa, 0x04, 0x1a, 0xc4, 0xdf, 0xca, 0x5e, 0xba, 0xc3, 0xbb,
0x55, 0xe0, 0x33, 0x7f, 0x8b, 0x45, 0xdd, 0x7a, 0x0a, 0x9d, 0x51, 0x49, 0xfd, 0x48, 0x9e, 0x8b,
0x1f, 0x85, 0x17, 0x34, 0xe1, 0x9b, 0x88, 0x49, 0x73, 0x1d, 0x5c, 0x4d, 0x5b, 0x0e, 0xe8, 0x62,
0x2f, 0x64, 0xc1, 0x9d, 0x8c, 0x6d, 0x7e, 0x3d, 0xdf, 0x5c, 0xaa, 0x3e, 0x74, 0xbc, 0x8f, 0xad,
0x21, 0x34, 0x9e, 0xf9, 0x5b, 0xf4, 0x04, 0x9a, 0x34, 0x49, 0xa2, 0x24, 0xf7, 0x7c, 0xbf, 0x6a,
0xe5, 0x54, 0x14, 0xb1, 0xc2, 0x58, 0xaf, 0x35, 0x68, 0xca, 0x04, 0xf2, 0x40, 0xf7, 0xa3, 0x40,
0xa9, 0xf6, 0x87, 0xd6, 0xad, 0x2c, 0xef, 0x24, 0x0a, 0x28, 0x96, 0x38, 0x64, 0x43, 0x37, 0xa0,
0xdc, 0x4f, 0x36, 0x71, 0x2a, 0x7c, 0xd7, 0xa5, 0xef, 0x72, 0xca, 0x79, 0x0a, 0xba, 0xc0, 0xa3,
0x2e, 0xb4, 0x17, 0x93, 0xef, 0x26, 0xd3, 0x1f, 0x26, 0x46, 0x0d, 0xd9, 0xf0, 0x70, 0x31, 0x99,
0x2f, 0x66, 0xb3, 0x29, 0x3e, 0x3f, 0xfd, 0xf6, 0xe5, 0x0c, 0x4f, 0xcf, 0xa7, 0x27, 0xd3, 0x17,
0x2f, 0x2f, 0x4e, 0xf1, 0x7c, 0x3c, 0x9d, 0x18, 0xe0, 0xfc, 0x56, 0x87, 0xde, 0x3c, 0x5b, 0xee,
0x75, 0xd0, 0x0b, 0xe8, 0x73, 0x15, 0x2f, 0xe9, 0x3c, 0x26, 0x7e, 0x71, 0x82, 0x8f, 0x0e, 0x1e,
0x4b, 0xf0, 0x22, 0xc8, 0xb1, 0xb8, 0xc2, 0x45, 0x18, 0x8c, 0x8c, 0x55, 0xf4, 0xd4, 0x93, 0xfa,
0xf4, 0x76, 0xbd, 0x45, 0x05, 0x8d, 0xdf, 0xe2, 0x5b, 0x8f, 0xa1, 0x7f, 0x73, 0x57, 0xf1, 0x76,
0xf3, 0xf8, 0x30, 0x15, 0x1d, 0x5c, 0x84, 0xd6, 0xe7, 0x60, 0x54, 0x15, 0xdf, 0x8d, 0x76, 0xfe,
0x6e, 0x82, 0x3e, 0xdf, 0x31, 0xff, 0xdd, 0x10, 0xf4, 0x15, 0xb4, 0x2f, 0xd5, 0x64, 0xe4, 0x7d,
0x94, 0xcf, 0x8e, 0xf9, 0xde, 0x49, 0xc4, 0x52, 0xca, 0xd2, 0x0b, 0x12, 0x66, 0x14, 0x17, 0x50,
0xf4, 0x04, 0x20, 0x4d, 0x28, 0x55, 0x43, 0x9c, 0xbf, 0xb5, 0x5d, 0x8f, 0xf8, 0x61, 0x31, 0xfe,
0xa5, 0x32, 0xfa, 0x10, 0x5a, 0x22, 0x1a, 0x07, 0x72, 0x26, 0x3b, 0x38, 0x8f, 0xac, 0xff, 0x34,
0xe8, 0x95, 0xe5, 0xd1, 0x37, 0x00, 0xe2, 0xd6, 0x58, 0xc4, 0x01, 0x49, 0x8b, 0x63, 0x32, 0x6f,
0xda, 0x19, 0xed, 0xeb, 0xa3, 0x1a, 0x2e, 0xa1, 0xd1, 0x19, 0x1c, 0xbd, 0xca, 0xc2, 0x50, 0x80,
0xb0, 0xba, 0x25, 0x6e, 0xef, 0xe7, 0x2c, 0x0b, 0x43, 0x2f, 0x47, 0x8c, 0x6a, 0xb8, 0x4a, 0x42,
0x63, 0x30, 0x0e, 0x29, 0x1e, 0x47, 0x8c, 0xd3, 0xbc, 0xbf, 0x07, 0xb7, 0x0a, 0x29, 0xc8, 0xa8,
0x86, 0xdf, 0xa2, 0x3d, 0x6f, 0x43, 0xf3, 0x67, 0xd1, 0x97, 0x15, 0x03, 0x1c, 0x7c, 0xa3, 0x7b,
0xd0, 0x14, 0xbe, 0xb9, 0xa9, 0xd9, 0x0d, 0xb7, 0x83, 0x55, 0x80, 0x5c, 0x68, 0xe7, 0x97, 0xad,
0x59, 0xb7, 0x1b, 0x6e, 0x77, 0xd8, 0x97, 0x8f, 0x13, 0x93, 0x5f, 0x4e, 0x64, 0x1a, 0x17, 0x65,
0xe4, 0x40, 0x8f, 0x33, 0x12, 0xf3, 0x75, 0x94, 0xce, 0x48, 0xba, 0x36, 0x1b, 0x52, 0xe6, 0x46,
0xce, 0xfa, 0x57, 0x03, 0x5d, 0x18, 0xb4, 0x2e, 0xa1, 0x5d, 0x74, 0xf6, 0x3e, 0xf6, 0x65, 0x70,
0xa7, 0x68, 0xff, 0x7d, 0xec, 0xf7, 0xf8, 0x02, 0xba, 0xa5, 0x7b, 0x1d, 0xdd, 0x87, 0x0f, 0x4a,
0xa1, 0xba, 0x7b, 0x8c, 0x1a, 0x7a, 0x00, 0x1f, 0x95, 0xd3, 0xa5, 0xf1, 0x34, 0x34, 0x74, 0x17,
0x8e, 0x6e, 0x70, 0x98, 0x6f, 0xd4, 0x9f, 0x3f, 0xfa, 0xf3, 0x6a, 0xa0, 0xbd, 0xb9, 0x1a, 0x68,
0xff, 0x5c, 0x0d, 0xb4, 0xd7, 0xd7, 0x83, 0xda, 0x9b, 0xeb, 0x41, 0xed, 0xaf, 0xeb, 0x41, 0xed,
0x47, 0x38, 0xde, 0xff, 0xb7, 0x2e, 0x5b, 0xf2, 0xe7, 0xcb, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff,
0x34, 0xaa, 0x76, 0x9b, 0x6f, 0x07, 0x00, 0x00,
}
func (m *Message) Marshal() (dAtA []byte, err error) {
@ -3328,7 +3326,7 @@ func (m *Sync) Unmarshal(dAtA []byte) error {
return io.ErrUnexpectedEOF
}
if m.TreeHeader == nil {
m.TreeHeader = &treepb.TreeHeader{}
m.TreeHeader = &aclpb.Header{}
}
if err := m.TreeHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err