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

Moving around files and refactoring of common

Browse source
This commit is contained in:
mcrakhman 2022-12-25 20:27:37 +01:00 • committed by Mikhail Iudin
parent 53e945b956
commit a66a356947
No known key found for this signature in database
GPG key ID: FAAAA8BAABDFF1C0
174 changed files with 1883 additions and 1543 deletions
Download patch file Download diff file Expand all files Collapse all files

10
client/account/service.go
View file

@ -1,21 +1,21 @@
package account
import (
commonaccount "github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
commonaccount "github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/config"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
)
type service struct {
accountData *account.AccountData
accountData *accountdata.AccountData
peerId string
}
func (s *service) Account() *account.AccountData {
func (s *service) Account() *accountdata.AccountData {
return s.accountData
}
@ -55,7 +55,7 @@ func (s *service) Init(a *app.App) (err error) {
return err
}
s.accountData = &account.AccountData{
s.accountData = &accountdata.AccountData{
Identity: identity,
PeerKey: decodedPeerKey,
SignKey: decodedSigningKey,

167
client/api/rpchandler.go
View file

@ -1,167 +0,0 @@
package api
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/api/apiproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
"math/rand"
)
type rpcHandler struct {
spaceService clientspace.Service
storageService storage.ClientStorage
docService document.Service
account account.Service
}
func (r *rpcHandler) Watch(ctx context.Context, request *apiproto.WatchRequest) (resp *apiproto.WatchResponse, err error) {
space, err := r.spaceService.GetSpace(context.Background(), request.SpaceId)
if err != nil {
return
}
space.StatusService().Watch(request.TreeId)
resp = &apiproto.WatchResponse{}
return
}
func (r *rpcHandler) Unwatch(ctx context.Context, request *apiproto.UnwatchRequest) (resp *apiproto.UnwatchResponse, err error) {
space, err := r.spaceService.GetSpace(context.Background(), request.SpaceId)
if err != nil {
return
}
space.StatusService().Unwatch(request.TreeId)
resp = &apiproto.UnwatchResponse{}
return
}
func (r *rpcHandler) LoadSpace(ctx context.Context, request *apiproto.LoadSpaceRequest) (resp *apiproto.LoadSpaceResponse, err error) {
_, err = r.spaceService.GetSpace(context.Background(), request.SpaceId)
if err != nil {
return
}
resp = &apiproto.LoadSpaceResponse{}
return
}
func (r *rpcHandler) CreateSpace(ctx context.Context, request *apiproto.CreateSpaceRequest) (resp *apiproto.CreateSpaceResponse, err error) {
key, err := symmetric.NewRandom()
if err != nil {
return
}
sp, err := r.spaceService.CreateSpace(context.Background(), commonspace.SpaceCreatePayload{
SigningKey: r.account.Account().SignKey,
EncryptionKey: r.account.Account().EncKey,
ReadKey: key.Bytes(),
ReplicationKey: rand.Uint64(),
})
if err != nil {
return
}
id := sp.Id()
if err != nil {
return
}
resp = &apiproto.CreateSpaceResponse{Id: id}
return
}
func (r *rpcHandler) DeriveSpace(ctx context.Context, request *apiproto.DeriveSpaceRequest) (resp *apiproto.DeriveSpaceResponse, err error) {
sp, err := r.spaceService.DeriveSpace(context.Background(), commonspace.SpaceDerivePayload{
SigningKey: r.account.Account().SignKey,
EncryptionKey: r.account.Account().EncKey,
})
if err != nil {
return
}
id := sp.Id()
if err != nil {
return
}
resp = &apiproto.DeriveSpaceResponse{Id: id}
return
}
func (r *rpcHandler) CreateDocument(ctx context.Context, request *apiproto.CreateDocumentRequest) (resp *apiproto.CreateDocumentResponse, err error) {
id, err := r.docService.CreateDocument(request.SpaceId)
if err != nil {
return
}
resp = &apiproto.CreateDocumentResponse{Id: id}
return
}
func (r *rpcHandler) DeleteDocument(ctx context.Context, request *apiproto.DeleteDocumentRequest) (resp *apiproto.DeleteDocumentResponse, err error) {
err = r.docService.DeleteDocument(request.SpaceId, request.DocumentId)
if err != nil {
return
}
resp = &apiproto.DeleteDocumentResponse{}
return
}
func (r *rpcHandler) AddText(ctx context.Context, request *apiproto.AddTextRequest) (resp *apiproto.AddTextResponse, err error) {
root, head, err := r.docService.AddText(request.SpaceId, request.DocumentId, request.Text, request.IsSnapshot)
if err != nil {
return
}
resp = &apiproto.AddTextResponse{
DocumentId: request.DocumentId,
HeadId: head,
RootId: root,
}
return
}
func (r *rpcHandler) DumpTree(ctx context.Context, request *apiproto.DumpTreeRequest) (resp *apiproto.DumpTreeResponse, err error) {
dump, err := r.docService.DumpDocumentTree(request.SpaceId, request.DocumentId)
if err != nil {
return
}
resp = &apiproto.DumpTreeResponse{
Dump: dump,
}
return
}
func (r *rpcHandler) AllTrees(ctx context.Context, request *apiproto.AllTreesRequest) (resp *apiproto.AllTreesResponse, err error) {
heads, err := r.docService.AllDocumentHeads(request.SpaceId)
if err != nil {
return
}
var trees []*apiproto.Tree
for _, head := range heads {
trees = append(trees, &apiproto.Tree{
Id: head.Id,
Heads: head.Heads,
})
}
resp = &apiproto.AllTreesResponse{Trees: trees}
return
}
func (r *rpcHandler) AllSpaces(ctx context.Context, request *apiproto.AllSpacesRequest) (resp *apiproto.AllSpacesResponse, err error) {
ids, err := r.storageService.AllSpaceIds()
if err != nil {
return
}
resp = &apiproto.AllSpacesResponse{SpaceIds: ids}
return
}
func (r *rpcHandler) TreeParams(ctx context.Context, request *apiproto.TreeParamsRequest) (resp *apiproto.TreeParamsResponse, err error) {
root, heads, err := r.docService.TreeParams(request.SpaceId, request.DocumentId)
if err != nil {
return
}
resp = &apiproto.TreeParamsResponse{
RootId: root,
HeadIds: heads,
}
return
}

18
client/clientspace/clientcache/treecache.go
View file

@ -5,12 +5,12 @@ import (
"errors"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document/textdocument"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ocache"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ocache"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter"
"go.uber.org/zap"
"time"
)
@ -25,7 +25,7 @@ const spaceKey ctxKey = 0
type treeCache struct {
gcttl int
cache ocache.OCache
account account.Service
account accountservice.Service
clientService clientspace.Service
}
@ -37,14 +37,14 @@ type TreeCache interface {
type updateListener struct {
}
func (u *updateListener) Update(tree tree.ObjectTree) {
func (u *updateListener) Update(tree objecttree.ObjectTree) {
log.With(
zap.Strings("heads", tree.Heads()),
zap.String("tree id", tree.ID())).
Debug("updating tree")
}
func (u *updateListener) Rebuild(tree tree.ObjectTree) {
func (u *updateListener) Rebuild(tree objecttree.ObjectTree) {
log.With(
zap.Strings("heads", tree.Heads()),
zap.String("tree id", tree.ID())).
@ -67,7 +67,7 @@ func (c *treeCache) Close(ctx context.Context) (err error) {
func (c *treeCache) Init(a *app.App) (err error) {
c.clientService = a.MustComponent(clientspace.CName).(clientspace.Service)
c.account = a.MustComponent(account.CName).(account.Service)
c.account = a.MustComponent(accountservice.CName).(accountservice.Service)
c.cache = ocache.New(
func(ctx context.Context, id string) (value ocache.Object, err error) {
spaceId := ctx.Value(spaceKey).(string)
@ -98,7 +98,7 @@ func (c *treeCache) GetDocument(ctx context.Context, spaceId, id string) (doc te
return
}
func (c *treeCache) GetTree(ctx context.Context, spaceId, id string) (tr tree.ObjectTree, err error) {
func (c *treeCache) GetTree(ctx context.Context, spaceId, id string) (tr objecttree.ObjectTree, err error) {
doc, err := c.GetDocument(ctx, spaceId, id)
if err != nil {
return

15
client/clientspace/service.go
View file

@ -4,12 +4,13 @@ import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ocache"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
config2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/config"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/rpc/server"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ocache"
"time"
)
@ -31,14 +32,14 @@ type Service interface {
type service struct {
conf config2.Space
spaceCache ocache.OCache
commonSpace commonspace.Service
spaceStorageProvider storage.SpaceStorageProvider
commonSpace commonspace.SpaceService
spaceStorageProvider spacestorage.SpaceStorageProvider
}
func (s *service) Init(a *app.App) (err error) {
s.conf = a.MustComponent(config2.CName).(*config2.Config).Space
s.commonSpace = a.MustComponent(commonspace.CName).(commonspace.Service)
s.spaceStorageProvider = a.MustComponent(storage.CName).(storage.SpaceStorageProvider)
s.commonSpace = a.MustComponent(commonspace.CName).(commonspace.SpaceService)
s.spaceStorageProvider = a.MustComponent(spacestorage.CName).(spacestorage.SpaceStorageProvider)
s.spaceCache = ocache.New(
s.loadSpace,
ocache.WithLogger(log.Sugar()),
@ -99,7 +100,7 @@ func (s *service) loadSpace(ctx context.Context, id string) (value ocache.Object
if err != nil {
return
}
ns.StatusService().SetUpdateReceiver(&statusReceiver{})
ns.SyncStatus().(syncstatus.SyncStatusWatcher).SetUpdateReceiver(&statusReceiver{})
if err = ns.Init(ctx); err != nil {
return
}

8
client/cmd/client.go
View file

@ -5,10 +5,10 @@ import (
"flag"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/api"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/badgerprovider"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace/clientcache"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/debug/clientdebugrpc"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/filestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/filestorage/rpcstore"
@ -22,7 +22,7 @@ import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/dialer"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/pool"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/rpc/server"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/secure"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/secureservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
"go.uber.org/zap"
"net/http"
@ -104,7 +104,7 @@ func Bootstrap(a *app.App) {
Register(badgerprovider.New()).
Register(storage.New()).
Register(clientcache.New(200)).
Register(secure.New()).
Register(secureservice.New()).
Register(dialer.New()).
Register(pool.New()).
Register(commonspace.New()).
@ -114,5 +114,5 @@ func Bootstrap(a *app.App) {
Register(rpcstore.New()).
Register(fileservice.New()).
Register(filestorage.New()).
Register(api.New())
Register(clientdebugrpc.New())
}

32
client/api/service.go → client/debug/clientdebugrpc/clientdebugrpc.go
View file

@ -1,51 +1,54 @@
package api
package clientdebugrpc
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/api/apiproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/debug/clientdebugrpc/clientdebugrpcproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document"
clientstorage "github.com/anytypeio/go-anytype-infrastructure-experiments/client/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonfile/fileservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/config"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/rpc/server"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/secure"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/secureservice"
"storj.io/drpc"
)
const CName = "api.service"
const CName = "debug.clientdebugrpc"
var log = logger.NewNamed(CName)
func New() Service {
func New() ClientDebugRpc {
return &service{BaseDrpcServer: server.NewBaseDrpcServer()}
}
type Service interface {
type ClientDebugRpc interface {
app.ComponentRunnable
drpc.Mux
}
type service struct {
transport secure.Service
transport secureservice.SecureService
cfg *config.Config
spaceService clientspace.Service
storageService clientstorage.ClientStorage
docService document.Service
account account.Service
account accountservice.Service
file fileservice.FileService
*server.BaseDrpcServer
}
func (s *service) Init(a *app.App) (err error) {
s.spaceService = a.MustComponent(clientspace.CName).(clientspace.Service)
s.storageService = a.MustComponent(storage.CName).(clientstorage.ClientStorage)
s.storageService = a.MustComponent(spacestorage.CName).(clientstorage.ClientStorage)
s.docService = a.MustComponent(document.CName).(document.Service)
s.account = a.MustComponent(account.CName).(account.Service)
s.account = a.MustComponent(accountservice.CName).(accountservice.Service)
s.cfg = a.MustComponent(config.CName).(*config.Config)
s.transport = a.MustComponent(secure.CName).(secure.Service)
s.transport = a.MustComponent(secureservice.CName).(secureservice.SecureService)
s.file = a.MustComponent(fileservice.CName).(fileservice.FileService)
return nil
}
@ -67,11 +70,12 @@ func (s *service) Run(ctx context.Context) (err error) {
if err != nil {
return
}
return apiproto.DRPCRegisterClientApi(s, &rpcHandler{
return clientdebugrpcproto.DRPCRegisterClientApi(s, &rpcHandler{
spaceService: s.spaceService,
storageService: s.storageService,
docService: s.docService,
account: s.account,
file: s.file,
})
}

2
client/api/apiproto/api.pb.go → client/debug/clientdebugrpc/clientdebugrpcproto/api.pb.go
View file

@ -1,7 +1,7 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: api/apiproto/protos/api.proto
package apiproto
package clientdebugrpcproto
import (
fmt "fmt"

2
client/api/apiproto/api_drpc.pb.go → client/debug/clientdebugrpc/clientdebugrpcproto/api_drpc.pb.go
View file

@ -2,7 +2,7 @@
// protoc-gen-go-drpc version: v0.0.32
// source: api/apiproto/protos/api.proto
package apiproto
package clientdebugrpcproto
import (
bytes "bytes"

0
client/api/apiproto/protos/api.proto → client/debug/clientdebugrpc/clientdebugrpcproto/protos/api.proto
View file

222
client/debug/clientdebugrpc/rpchandler.go Normal file
View file

@ -0,0 +1,222 @@
package clientdebugrpc
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/debug/clientdebugrpc/clientdebugrpcproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonfile/fileservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
"github.com/ipfs/go-cid"
"go.uber.org/zap"
"io"
"math/rand"
"os"
)
type rpcHandler struct {
spaceService clientspace.Service
storageService storage.ClientStorage
docService document.Service
account accountservice.Service
file fileservice.FileService
}
func (r *rpcHandler) Watch(ctx context.Context, request *clientdebugrpcproto.WatchRequest) (resp *clientdebugrpcproto.WatchResponse, err error) {
space, err := r.spaceService.GetSpace(context.Background(), request.SpaceId)
if err != nil {
return
}
watcher := space.SyncStatus().(syncstatus.SyncStatusWatcher)
watcher.Watch(request.TreeId)
resp = &clientdebugrpcproto.WatchResponse{}
return
}
func (r *rpcHandler) Unwatch(ctx context.Context, request *clientdebugrpcproto.UnwatchRequest) (resp *clientdebugrpcproto.UnwatchResponse, err error) {
space, err := r.spaceService.GetSpace(context.Background(), request.SpaceId)
if err != nil {
return
}
watcher := space.SyncStatus().(syncstatus.SyncStatusWatcher)
watcher.Unwatch(request.TreeId)
resp = &clientdebugrpcproto.UnwatchResponse{}
return
}
func (r *rpcHandler) LoadSpace(ctx context.Context, request *clientdebugrpcproto.LoadSpaceRequest) (resp *clientdebugrpcproto.LoadSpaceResponse, err error) {
_, err = r.spaceService.GetSpace(context.Background(), request.SpaceId)
if err != nil {
return
}
resp = &clientdebugrpcproto.LoadSpaceResponse{}
return
}
func (r *rpcHandler) CreateSpace(ctx context.Context, request *clientdebugrpcproto.CreateSpaceRequest) (resp *clientdebugrpcproto.CreateSpaceResponse, err error) {
key, err := symmetric.NewRandom()
if err != nil {
return
}
sp, err := r.spaceService.CreateSpace(context.Background(), commonspace.SpaceCreatePayload{
SigningKey: r.account.Account().SignKey,
EncryptionKey: r.account.Account().EncKey,
ReadKey: key.Bytes(),
ReplicationKey: rand.Uint64(),
})
if err != nil {
return
}
id := sp.Id()
if err != nil {
return
}
resp = &clientdebugrpcproto.CreateSpaceResponse{Id: id}
return
}
func (r *rpcHandler) DeriveSpace(ctx context.Context, request *clientdebugrpcproto.DeriveSpaceRequest) (resp *clientdebugrpcproto.DeriveSpaceResponse, err error) {
sp, err := r.spaceService.DeriveSpace(context.Background(), commonspace.SpaceDerivePayload{
SigningKey: r.account.Account().SignKey,
EncryptionKey: r.account.Account().EncKey,
})
if err != nil {
return
}
id := sp.Id()
if err != nil {
return
}
resp = &clientdebugrpcproto.DeriveSpaceResponse{Id: id}
return
}
func (r *rpcHandler) CreateDocument(ctx context.Context, request *clientdebugrpcproto.CreateDocumentRequest) (resp *clientdebugrpcproto.CreateDocumentResponse, err error) {
id, err := r.docService.CreateDocument(request.SpaceId)
if err != nil {
return
}
resp = &clientdebugrpcproto.CreateDocumentResponse{Id: id}
return
}
func (r *rpcHandler) DeleteDocument(ctx context.Context, request *clientdebugrpcproto.DeleteDocumentRequest) (resp *clientdebugrpcproto.DeleteDocumentResponse, err error) {
err = r.docService.DeleteDocument(request.SpaceId, request.DocumentId)
if err != nil {
return
}
resp = &clientdebugrpcproto.DeleteDocumentResponse{}
return
}
func (r *rpcHandler) AddText(ctx context.Context, request *clientdebugrpcproto.AddTextRequest) (resp *clientdebugrpcproto.AddTextResponse, err error) {
root, head, err := r.docService.AddText(request.SpaceId, request.DocumentId, request.Text, request.IsSnapshot)
if err != nil {
return
}
resp = &clientdebugrpcproto.AddTextResponse{
DocumentId: request.DocumentId,
HeadId: head,
RootId: root,
}
return
}
func (r *rpcHandler) DumpTree(ctx context.Context, request *clientdebugrpcproto.DumpTreeRequest) (resp *clientdebugrpcproto.DumpTreeResponse, err error) {
dump, err := r.docService.DumpDocumentTree(request.SpaceId, request.DocumentId)
if err != nil {
return
}
resp = &clientdebugrpcproto.DumpTreeResponse{
Dump: dump,
}
return
}
func (r *rpcHandler) AllTrees(ctx context.Context, request *clientdebugrpcproto.AllTreesRequest) (resp *clientdebugrpcproto.AllTreesResponse, err error) {
heads, err := r.docService.AllDocumentHeads(request.SpaceId)
if err != nil {
return
}
var trees []*clientdebugrpcproto.Tree
for _, head := range heads {
trees = append(trees, &clientdebugrpcproto.Tree{
Id: head.Id,
Heads: head.Heads,
})
}
resp = &clientdebugrpcproto.AllTreesResponse{Trees: trees}
return
}
func (r *rpcHandler) AllSpaces(ctx context.Context, request *clientdebugrpcproto.AllSpacesRequest) (resp *clientdebugrpcproto.AllSpacesResponse, err error) {
ids, err := r.storageService.AllSpaceIds()
if err != nil {
return
}
resp = &clientdebugrpcproto.AllSpacesResponse{SpaceIds: ids}
return
}
func (r *rpcHandler) TreeParams(ctx context.Context, request *clientdebugrpcproto.TreeParamsRequest) (resp *clientdebugrpcproto.TreeParamsResponse, err error) {
root, heads, err := r.docService.TreeParams(request.SpaceId, request.DocumentId)
if err != nil {
return
}
resp = &clientdebugrpcproto.TreeParamsResponse{
RootId: root,
HeadIds: heads,
}
return
}
func (r *rpcHandler) PutFile(ctx context.Context, request *clientdebugrpcproto.PutFileRequest) (*clientdebugrpcproto.PutFileResponse, error) {
f, err := os.Open(request.Path)
if err != nil {
return nil, err
}
defer f.Close()
n, err := r.file.AddFile(ctx, f)
if err != nil {
return nil, err
}
return &clientdebugrpcproto.PutFileResponse{
Hash: n.Cid().String(),
}, nil
}
func (r *rpcHandler) GetFile(ctx context.Context, request *clientdebugrpcproto.GetFileRequest) (*clientdebugrpcproto.GetFileResponse, error) {
c, err := cid.Parse(request.Hash)
if err != nil {
return nil, err
}
f, err := os.Create(request.Path)
if err != nil {
return nil, err
}
defer f.Close()
rd, err := r.file.GetFile(ctx, c)
if err != nil {
return nil, err
}
defer rd.Close()
wr, err := io.Copy(f, rd)
if err != nil && err != io.EOF {
return nil, err
}
log.Info("copied bytes", zap.Int64("size", wr))
return &clientdebugrpcproto.GetFileResponse{
Path: request.Path,
}, nil
}
func (r *rpcHandler) DeleteFile(ctx context.Context, request *clientdebugrpcproto.DeleteFileRequest) (*clientdebugrpcproto.DeleteFileResponse, error) {
//TODO implement me
panic("implement me")
}

9
client/document/service.go
View file

@ -5,10 +5,11 @@ import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace/clientcache"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document/textdocument"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/headsync"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter"
)
type Service interface {
@ -27,7 +28,7 @@ const CName = "client.document"
var log = logger.NewNamed(CName)
type service struct {
account account.Service
account accountservice.Service
spaceService clientspace.Service
cache clientcache.TreeCache
}
@ -37,7 +38,7 @@ func New() Service {
}
func (s *service) Init(a *app.App) (err error) {
s.account = a.MustComponent(account.CName).(account.Service)
s.account = a.MustComponent(accountservice.CName).(accountservice.Service)
s.spaceService = a.MustComponent(clientspace.CName).(clientspace.Service)
s.cache = a.MustComponent(treegetter.CName).(clientcache.TreeCache)
return

4
common/pkg/acl/testutils/testchanges/proto/test.proto → client/document/textchangeproto/protos/test.proto
View file

@ -1,6 +1,6 @@
syntax = "proto3";
package anytype;
option go_package = "testchanges";
package textchange;
option go_package = "textchange";
message TextContent {
oneof value {

2
common/pkg/acl/testutils/testchanges/proto/test.pb.go → client/document/textchangeproto/test.pb.go
View file

@ -1,7 +1,7 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pkg/acl/testutils/testchanges/proto/test.proto
package testchanges
package textchangeproto
import (
fmt "fmt"

38
client/document/textdocument/textdocument.go
View file

@ -2,17 +2,17 @@ package textdocument
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
textchange "github.com/anytypeio/go-anytype-infrastructure-experiments/client/document/textchangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener"
testchanges "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/testchanges/proto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener"
"github.com/gogo/protobuf/proto"
)
type TextDocument interface {
tree.ObjectTree
InnerTree() tree.ObjectTree
objecttree.ObjectTree
InnerTree() objecttree.ObjectTree
AddText(text string, isSnapshot bool) (string, string, error)
Text() (string, error)
TreeDump() string
@ -20,15 +20,15 @@ type TextDocument interface {
}
type textDocument struct {
tree.ObjectTree
account account.Service
objecttree.ObjectTree
account accountservice.Service
}
func CreateTextDocument(
ctx context.Context,
space commonspace.Space,
account account.Service) (id string, err error) {
payload := tree.ObjectTreeCreatePayload{
account accountservice.Service) (id string, err error) {
payload := objecttree.ObjectTreeCreatePayload{
SignKey: account.Account().SignKey,
SpaceId: space.Id(),
Identity: account.Account().Identity,
@ -36,7 +36,7 @@ func CreateTextDocument(
return space.CreateTree(ctx, payload)
}
func NewTextDocument(ctx context.Context, space commonspace.Space, id string, listener updatelistener.UpdateListener, account account.Service) (doc TextDocument, err error) {
func NewTextDocument(ctx context.Context, space commonspace.Space, id string, listener updatelistener.UpdateListener, account accountservice.Service) (doc TextDocument, err error) {
t, err := space.BuildTree(ctx, id, listener)
if err != nil {
return
@ -47,16 +47,16 @@ func NewTextDocument(ctx context.Context, space commonspace.Space, id string, li
}, nil
}
func (t *textDocument) InnerTree() tree.ObjectTree {
func (t *textDocument) InnerTree() objecttree.ObjectTree {
return t.ObjectTree
}
func (t *textDocument) AddText(text string, isSnapshot bool) (root, head string, err error) {
content := &testchanges.TextContent_TextAppend{
TextAppend: &testchanges.TextAppend{Text: text},
content := &textchange.TextContent_TextAppend{
TextAppend: &textchange.TextAppend{Text: text},
}
change := &testchanges.TextData{
Content: []*testchanges.TextContent{
change := &textchange.TextData{
Content: []*textchange.TextContent{
{content},
},
Snapshot: nil,
@ -67,7 +67,7 @@ func (t *textDocument) AddText(text string, isSnapshot bool) (root, head string,
}
t.Lock()
defer t.Unlock()
addRes, err := t.AddContent(context.Background(), tree.SignableChangeContent{
addRes, err := t.AddContent(context.Background(), objecttree.SignableChangeContent{
Data: res,
Key: t.account.Account().SignKey,
Identity: t.account.Account().Identity,
@ -87,7 +87,7 @@ func (t *textDocument) Text() (text string, err error) {
err = t.Iterate(
func(decrypted []byte) (any, error) {
textChange := &testchanges.TextData{}
textChange := &textchange.TextData{}
err = proto.Unmarshal(decrypted, textChange)
if err != nil {
return nil, err
@ -98,7 +98,7 @@ func (t *textDocument) Text() (text string, err error) {
}
}
return textChange, nil
}, func(change *tree.Change) bool {
}, func(change *objecttree.Change) bool {
return true
})
return

2
client/filestorage/rpcstore/clientmgr.go
View file

@ -3,7 +3,7 @@ package rpcstore
import (
"context"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ocache"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ocache"
"github.com/cheggaaa/mb/v3"
"go.uber.org/zap"
"math/rand"

24
client/storage/keys.go
View file

@ -1,7 +1,7 @@
package storage
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
)
type aclKeys struct {
@ -13,8 +13,8 @@ type aclKeys struct {
func newACLKeys(spaceId string) aclKeys {
return aclKeys{
spaceId: spaceId,
rootKey: storage.JoinStringsToBytes("space", spaceId, "a", "rootId"),
headKey: storage.JoinStringsToBytes("space", spaceId, "a", "headId"),
rootKey: treestorage.JoinStringsToBytes("space", spaceId, "a", "rootId"),
headKey: treestorage.JoinStringsToBytes("space", spaceId, "a", "headId"),
}
}
@ -27,7 +27,7 @@ func (a aclKeys) RootIdKey() []byte {
}
func (a aclKeys) RawRecordKey(id string) []byte {
return storage.JoinStringsToBytes("space", a.spaceId, "a", id)
return treestorage.JoinStringsToBytes("space", a.spaceId, "a", id)
}
type treeKeys struct {
@ -42,9 +42,9 @@ func newTreeKeys(spaceId, id string) treeKeys {
return treeKeys{
id: id,
spaceId: spaceId,
headsKey: storage.JoinStringsToBytes("space", spaceId, "t", id, "heads"),
rootKey: storage.JoinStringsToBytes("space", spaceId, "t", "rootId", id),
rawChangePrefix: storage.JoinStringsToBytes("space", spaceId, "t", id),
headsKey: treestorage.JoinStringsToBytes("space", spaceId, "t", id, "heads"),
rootKey: treestorage.JoinStringsToBytes("space", spaceId, "t", "rootId", id),
rawChangePrefix: treestorage.JoinStringsToBytes("space", spaceId, "t", id),
}
}
@ -57,7 +57,7 @@ func (t treeKeys) RootIdKey() []byte {
}
func (t treeKeys) RawChangeKey(id string) []byte {
return storage.JoinStringsToBytes("space", t.spaceId, "t", t.id, id)
return treestorage.JoinStringsToBytes("space", t.spaceId, "t", t.id, id)
}
func (t treeKeys) RawChangePrefix() []byte {
@ -74,9 +74,9 @@ type spaceKeys struct {
func newSpaceKeys(spaceId string) spaceKeys {
return spaceKeys{
spaceId: spaceId,
headerKey: storage.JoinStringsToBytes("space", "header", spaceId),
treePrefixKey: storage.JoinStringsToBytes("space", spaceId, "t", "rootId"),
spaceSettingsIdKey: storage.JoinStringsToBytes("space", spaceId, "spaceSettingsId"),
headerKey: treestorage.JoinStringsToBytes("space", "header", spaceId),
treePrefixKey: treestorage.JoinStringsToBytes("space", spaceId, "t", "rootId"),
spaceSettingsIdKey: treestorage.JoinStringsToBytes("space", spaceId, "spaceSettingsId"),
}
}
@ -93,7 +93,7 @@ func (s spaceKeys) SpaceSettingsId() []byte {
}
func (s spaceKeys) TreeDeletedKey(id string) []byte {
return storage.JoinStringsToBytes("space", s.spaceId, "deleted", id)
return treestorage.JoinStringsToBytes("space", s.spaceId, "deleted", id)
}
type storageServiceKeys struct {

10
client/storage/liststorage.go
View file

@ -3,8 +3,8 @@ package storage
import (
"context"
"errors"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage"
"github.com/dgraph-io/badger/v3"
)
@ -17,7 +17,7 @@ type listStorage struct {
root *aclrecordproto.RawACLRecordWithId
}
func newListStorage(spaceId string, db *badger.DB, txn *badger.Txn) (ls storage.ListStorage, err error) {
func newListStorage(spaceId string, db *badger.DB, txn *badger.Txn) (ls liststorage.ListStorage, err error) {
keys := newACLKeys(spaceId)
rootId, err := getTxn(txn, keys.RootIdKey())
if err != nil {
@ -44,7 +44,7 @@ func newListStorage(spaceId string, db *badger.DB, txn *badger.Txn) (ls storage.
return
}
func createListStorage(spaceId string, db *badger.DB, txn *badger.Txn, root *aclrecordproto.RawACLRecordWithId) (ls storage.ListStorage, err error) {
func createListStorage(spaceId string, db *badger.DB, txn *badger.Txn, root *aclrecordproto.RawACLRecordWithId) (ls liststorage.ListStorage, err error) {
keys := newACLKeys(spaceId)
_, err = getTxn(txn, keys.RootIdKey())
if err != badger.ErrKeyNotFound {
@ -98,7 +98,7 @@ func (l *listStorage) GetRawRecord(ctx context.Context, id string) (raw *aclreco
res, err := getDB(l.db, l.keys.RawRecordKey(id))
if err != nil {
if err == badger.ErrKeyNotFound {
err = storage.ErrUnknownRecord
err = liststorage.ErrUnknownRecord
}
return
}

10
client/storage/liststorage_test.go
View file

@ -2,15 +2,15 @@ package storage
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage"
"github.com/dgraph-io/badger/v3"
"github.com/stretchr/testify/require"
"testing"
)
func testList(t *testing.T, store storage.ListStorage, root *aclrecordproto.RawACLRecordWithId, head string) {
require.Equal(t, store.ID(), root.Id)
func testList(t *testing.T, store liststorage.ListStorage, root *aclrecordproto.RawACLRecordWithId, head string) {
require.Equal(t, store.Id(), root.Id)
aclRoot, err := store.Root()
require.NoError(t, err)
@ -34,7 +34,7 @@ func TestListStorage(t *testing.T) {
return nil
})
var listStore storage.ListStorage
var listStore liststorage.ListStorage
fx.db.View(func(txn *badger.Txn) (err error) {
listStore, err = newListStorage(spaceId, fx.db, txn)
require.NoError(t, err)

11
client/storage/spacestorage.go
View file

@ -1,10 +1,11 @@
package storage
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/dgraph-io/badger/v3"
)
@ -13,7 +14,7 @@ type spaceStorage struct {
spaceSettingsId string
objDb *badger.DB
keys spaceKeys
aclStorage storage.ListStorage
aclStorage liststorage.ListStorage
header *spacesyncproto.RawSpaceHeaderWithId
}
@ -119,7 +120,7 @@ func (s *spaceStorage) CreateTreeStorage(payload storage.TreeStorageCreatePayloa
return createTreeStorage(s.objDb, s.spaceId, payload)
}
func (s *spaceStorage) ACLStorage() (storage.ListStorage, error) {
func (s *spaceStorage) ACLStorage() (liststorage.ListStorage, error) {
return s.aclStorage, nil
}

6
client/storage/spacestorage_test.go
View file

@ -1,10 +1,10 @@
package storage
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/stretchr/testify/require"
"sort"
"strconv"

10
client/storage/storageservice.go
View file

@ -4,7 +4,7 @@ import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/badgerprovider"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
"github.com/dgraph-io/badger/v3"
)
@ -14,7 +14,7 @@ type storageService struct {
}
type ClientStorage interface {
storage.SpaceStorageProvider
spacestorage.SpaceStorageProvider
app.ComponentRunnable
AllSpaceIds() (ids []string, err error)
}
@ -31,14 +31,14 @@ func (s *storageService) Init(a *app.App) (err error) {
}
func (s *storageService) Name() (name string) {
return storage.CName
return spacestorage.CName
}
func (s *storageService) SpaceStorage(id string) (storage.SpaceStorage, error) {
func (s *storageService) SpaceStorage(id string) (spacestorage.SpaceStorage, error) {
return newSpaceStorage(s.db, id)
}
func (s *storageService) CreateSpaceStorage(payload storage.SpaceStorageCreatePayload) (storage.SpaceStorage, error) {
func (s *storageService) CreateSpaceStorage(payload spacestorage.SpaceStorageCreatePayload) (spacestorage.SpaceStorage, error) {
return createSpaceStorage(s.db, payload)
}

25
client/storage/treestorage.go
View file

@ -2,8 +2,8 @@ package storage
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
"github.com/dgraph-io/badger/v3"
)
@ -14,7 +14,7 @@ type treeStorage struct {
root *treechangeproto.RawTreeChangeWithId
}
func newTreeStorage(db *badger.DB, spaceId, treeId string) (ts storage.TreeStorage, err error) {
func newTreeStorage(db *badger.DB, spaceId, treeId string) (ts treestorage.TreeStorage, err error) {
keys := newTreeKeys(spaceId, treeId)
err = db.View(func(txn *badger.Txn) error {
_, err := txn.Get(keys.RootIdKey())
@ -40,17 +40,20 @@ func newTreeStorage(db *badger.DB, spaceId, treeId string) (ts storage.TreeStora
}
return nil
})
if err == badger.ErrKeyNotFound {
err = treestorage.ErrUnknownTreeId
}
return
}
func createTreeStorage(db *badger.DB, spaceId string, payload storage.TreeStorageCreatePayload) (ts storage.TreeStorage, err error) {
keys := newTreeKeys(spaceId, payload.TreeId)
func createTreeStorage(db *badger.DB, spaceId string, payload treestorage.TreeStorageCreatePayload) (ts treestorage.TreeStorage, err error) {
keys := newTreeKeys(spaceId, payload.RootRawChange.Id)
if hasDB(db, keys.RootIdKey()) {
err = storage.ErrTreeExists
err = treestorage.ErrTreeExists
return
}
err = db.Update(func(txn *badger.Txn) error {
heads := storage.CreateHeadsPayload(payload.Heads)
heads := treestorage.CreateHeadsPayload(payload.Heads)
for _, ch := range payload.Changes {
err = txn.Set(keys.RawChangeKey(ch.Id), ch.GetRawChange())
@ -97,16 +100,16 @@ func (t *treeStorage) Heads() (heads []string, err error) {
headsBytes, err := getDB(t.db, t.keys.HeadsKey())
if err != nil {
if err == badger.ErrKeyNotFound {
err = storage.ErrUnknownTreeId
err = treestorage.ErrUnknownTreeId
}
return
}
heads = storage.ParseHeads(headsBytes)
heads = treestorage.ParseHeads(headsBytes)
return
}
func (t *treeStorage) SetHeads(heads []string) (err error) {
payload := storage.CreateHeadsPayload(heads)
payload := treestorage.CreateHeadsPayload(heads)
return putDB(t.db, t.keys.HeadsKey(), payload)
}
@ -118,7 +121,7 @@ func (t *treeStorage) GetRawChange(ctx context.Context, id string) (raw *treecha
res, err := getDB(t.db, t.keys.RawChangeKey(id))
if err != nil {
if err == badger.ErrKeyNotFound {
err = storage.ErrUnknownTreeId
err = treestorage.ErrUnknownTreeId
}
return
}

14
client/storage/treestorage_test.go
View file

@ -2,19 +2,19 @@ package storage
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
"github.com/dgraph-io/badger/v3"
"github.com/stretchr/testify/require"
"os"
"testing"
)
func treeTestPayload() storage.TreeStorageCreatePayload {
func treeTestPayload() treestorage.TreeStorageCreatePayload {
rootRawChange := &treechangeproto.RawTreeChangeWithId{RawChange: []byte("some"), Id: "someRootId"}
otherChange := &treechangeproto.RawTreeChangeWithId{RawChange: []byte("some other"), Id: "otherId"}
changes := []*treechangeproto.RawTreeChangeWithId{rootRawChange, otherChange}
return storage.TreeStorageCreatePayload{
return treestorage.TreeStorageCreatePayload{
RootRawChange: rootRawChange,
Changes: changes,
Heads: []string{rootRawChange.Id},
@ -26,8 +26,8 @@ type fixture struct {
db *badger.DB
}
func testTreePayload(t *testing.T, store storage.TreeStorage, payload storage.TreeStorageCreatePayload) {
require.Equal(t, payload.RootRawChange.Id, store.ID())
func testTreePayload(t *testing.T, store treestorage.TreeStorage, payload treestorage.TreeStorageCreatePayload) {
require.Equal(t, payload.RootRawChange.Id, store.Id())
root, err := store.Root()
require.NoError(t, err)
@ -181,7 +181,7 @@ func TestTreeStorage_Delete(t *testing.T) {
require.NoError(t, err)
_, err = newTreeStorage(fx.db, spaceId, payload.RootRawChange.Id)
require.Equal(t, err, storage.ErrUnknownTreeId)
require.Equal(t, err, treestorage.ErrUnknownTreeId)
fx.testNoKeysExist(t, spaceId, payload.RootRawChange.Id)
})

8
common/account/service.go → common/accountservice/accountservice.go
View file

@ -1,17 +1,17 @@
//go:generate mockgen -destination mock_account/mock_account.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/account Service
package account
//go:generate mockgen -destination mock_accountservice/mock_accountservice.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice Service
package accountservice
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/config"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
)
const CName = "common.account"
type Service interface {
app.Component
Account() *account.AccountData
Account() *accountdata.AccountData
}
type ConfigGetter interface {

12
common/account/mock_account/mock_account.go → common/accountservice/mock_accountservice/mock_accountservice.go
View file

@ -1,14 +1,14 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/account (interfaces: Service)
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/accountservice (interfaces: Service)
// Package mock_account is a generated GoMock package.
package mock_account
// Package mock_accountservice is a generated GoMock package.
package mock_accountservice
import (
reflect "reflect"
app "github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
account "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
accountdata "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
gomock "github.com/golang/mock/gomock"
)
@ -36,10 +36,10 @@ func (m *MockService) EXPECT() *MockServiceMockRecorder {
}
// Account mocks base method.
func (m *MockService) Account() *account.AccountData {
func (m *MockService) Account() *accountdata.AccountData {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Account")
ret0, _ := ret[0].(*account.AccountData)
ret0, _ := ret[0].(*accountdata.AccountData)
return ret0
}

2
common/pkg/ldiff/diff.go → common/app/ldiff/diff.go
View file

@ -1,7 +1,7 @@
// Package ldiff provides a container of elements with fixed id and changeable content.
// Diff can calculate the difference with another diff container (you can make it remote) with minimum hops and traffic.
//
//go:generate mockgen -destination mock_ldiff/mock_ldiff.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff Diff,Remote
//go:generate mockgen -destination mock_ldiff/mock_ldiff.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff Diff,Remote
package ldiff
import (

0
common/pkg/ldiff/diff_test.go → common/app/ldiff/diff_test.go
View file

4
common/pkg/ldiff/mock_ldiff/mock_ldiff.go → common/app/ldiff/mock_ldiff/mock_ldiff.go
View file

@ -1,5 +1,5 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff (interfaces: Diff,Remote)
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff (interfaces: Diff,Remote)
// Package mock_ldiff is a generated GoMock package.
package mock_ldiff
@ -8,7 +8,7 @@ import (
context "context"
reflect "reflect"
ldiff "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
ldiff "github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
gomock "github.com/golang/mock/gomock"
)

0
common/pkg/ocache/metrics.go → common/app/ocache/metrics.go
View file

0
common/pkg/ocache/ocache.go → common/app/ocache/ocache.go
View file

0
common/pkg/ocache/ocache_test.go → common/app/ocache/ocache_test.go
View file

14
common/commonspace/commongetter.go
View file

@ -2,10 +2,10 @@ package commonspace
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectgetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/syncacl"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/syncobjectgetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settings"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncacl"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
)
type commonSpaceGetter struct {
@ -15,7 +15,7 @@ type commonSpaceGetter struct {
settings settings.SettingsObject
}
func newCommonSpaceGetter(spaceId string, aclList *syncacl.SyncACL, treeGetter treegetter.TreeGetter, settings settings.SettingsObject) objectgetter.ObjectGetter {
func newCommonSpaceGetter(spaceId string, aclList *syncacl.SyncACL, treeGetter treegetter.TreeGetter, settings settings.SettingsObject) syncobjectgetter.SyncObjectGetter {
return &commonSpaceGetter{
spaceId: spaceId,
aclList: aclList,
@ -24,19 +24,19 @@ func newCommonSpaceGetter(spaceId string, aclList *syncacl.SyncACL, treeGetter t
}
}
func (c *commonSpaceGetter) GetObject(ctx context.Context, objectId string) (obj objectgetter.Object, err error) {
func (c *commonSpaceGetter) GetObject(ctx context.Context, objectId string) (obj syncobjectgetter.SyncObject, err error) {
if c.aclList.ID() == objectId {
obj = c.aclList
return
}
if c.settings.ID() == objectId {
obj = c.settings.(objectgetter.Object)
obj = c.settings.(syncobjectgetter.SyncObject)
return
}
t, err := c.treeGetter.GetTree(ctx, c.spaceId, objectId)
if err != nil {
return
}
obj = t.(objectgetter.Object)
obj = t.(syncobjectgetter.SyncObject)
return
}

10
common/commonspace/commonstorage.go
View file

@ -1,15 +1,15 @@
package commonspace
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
treestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
)
type commonStorage struct {
storage.SpaceStorage
spacestorage.SpaceStorage
}
func newCommonStorage(spaceStorage storage.SpaceStorage) storage.SpaceStorage {
func newCommonStorage(spaceStorage spacestorage.SpaceStorage) spacestorage.SpaceStorage {
return &commonStorage{
SpaceStorage: spaceStorage,
}
@ -23,6 +23,6 @@ func (c *commonStorage) CreateTreeStorage(payload treestorage.TreeStorageCreateP
if status == "" {
return c.SpaceStorage.CreateTreeStorage(payload)
}
err = storage.ErrTreeStorageAlreadyDeleted
err = spacestorage.ErrTreeStorageAlreadyDeleted
return
}

12
common/commonspace/headsync/diffsyncer.go
View file

@ -2,16 +2,16 @@ package headsync
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settings/deletionstate"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/peer"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/rpc/rpcerr"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
"go.uber.org/zap"
"time"
)
@ -28,7 +28,7 @@ func newDiffSyncer(
diff ldiff.Diff,
confConnector nodeconf.ConfConnector,
cache treegetter.TreeGetter,
storage storage.SpaceStorage,
storage spacestorage.SpaceStorage,
clientFactory spacesyncproto.ClientFactory,
syncStatus syncstatus.SyncStatusUpdater,
log *zap.Logger) DiffSyncer {
@ -49,7 +49,7 @@ type diffSyncer struct {
diff ldiff.Diff
confConnector nodeconf.ConfConnector
cache treegetter.TreeGetter
storage storage.SpaceStorage
storage spacestorage.SpaceStorage
clientFactory spacesyncproto.ClientFactory
log *zap.Logger
deletionState deletionstate.DeletionState

19
common/commonspace/headsync/diffsyncer_test.go
View file

@ -3,21 +3,20 @@ package headsync
import (
"context"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff/mock_ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
mock_treestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage/mock_treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter/mock_treegetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settings/deletionstate/mock_deletionstate"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage/mock_spacestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto/mock_spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage/mock_storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter/mock_treegetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/peer"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf/mock_nodeconf"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
mock_aclstorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage/mock_storage"
mock_treestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage/mock_storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff/mock_ldiff"
"github.com/golang/mock/gomock"
"github.com/libp2p/go-libp2p/core/sec"
"github.com/stretchr/testify/require"
@ -101,7 +100,7 @@ func TestDiffSyncer_Sync(t *testing.T) {
diffMock := mock_ldiff.NewMockDiff(ctrl)
connectorMock := mock_nodeconf.NewMockConfConnector(ctrl)
cacheMock := mock_treegetter.NewMockTreeGetter(ctrl)
stMock := mock_storage.NewMockSpaceStorage(ctrl)
stMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
clientMock := mock_spacesyncproto.NewMockDRPCSpaceClient(ctrl)
factory := spacesyncproto.ClientFactoryFunc(func(cc drpc.Conn) spacesyncproto.DRPCSpaceClient {
return clientMock
@ -158,7 +157,7 @@ func TestDiffSyncer_Sync(t *testing.T) {
})
t.Run("diff syncer sync space missing", func(t *testing.T) {
aclStorageMock := mock_aclstorage.NewMockListStorage(ctrl)
aclStorageMock := mock_treestorage.NewMockListStorage(ctrl)
settingsStorage := mock_treestorage.NewMockTreeStorage(ctrl)
settingsId := "settingsId"
aclRoot := &aclrecordproto.RawACLRecordWithId{

10
common/commonspace/headsync/headsync.go
View file

@ -3,13 +3,13 @@ package headsync
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/treegetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settings/deletionstate"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/treegetter"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/periodicsync"
"go.uber.org/zap"
"strings"
@ -35,7 +35,7 @@ type HeadSync interface {
type headSync struct {
spaceId string
periodicSync periodicsync.PeriodicSync
storage storage.SpaceStorage
storage spacestorage.SpaceStorage
diff ldiff.Diff
log *zap.Logger
syncer DiffSyncer
@ -46,7 +46,7 @@ type headSync struct {
func NewHeadSync(
spaceId string,
syncPeriod int,
storage storage.SpaceStorage,
storage spacestorage.SpaceStorage,
confConnector nodeconf.ConfConnector,
cache treegetter.TreeGetter,
syncStatus syncstatus.SyncStatusUpdater,

12
common/commonspace/headsync/headsync_test.go
View file

@ -1,13 +1,13 @@
package headsync
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff/mock_ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/headsync/mock_headsync"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage/mock_treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/settings/deletionstate/mock_deletionstate"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage/mock_storage"
mock_storage2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage/mock_storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff/mock_ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage/mock_spacestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/periodicsync/mock_periodicsync"
"github.com/golang/mock/gomock"
"testing"
@ -20,8 +20,8 @@ func TestDiffService(t *testing.T) {
spaceId := "spaceId"
l := logger.NewNamed("sync")
pSyncMock := mock_periodicsync.NewMockPeriodicSync(ctrl)
storageMock := mock_storage.NewMockSpaceStorage(ctrl)
treeStorageMock := mock_storage2.NewMockTreeStorage(ctrl)
storageMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
treeStorageMock := mock_treestorage.NewMockTreeStorage(ctrl)
diffMock := mock_ldiff.NewMockDiff(ctrl)
syncer := mock_headsync.NewMockDiffSyncer(ctrl)
delState := mock_deletionstate.NewMockDeletionState(ctrl)

2
common/commonspace/headsync/remotediff.go
View file

@ -2,8 +2,8 @@ package headsync
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
)
type Client interface {

2
common/commonspace/headsync/remotediff_test.go
View file

@ -3,8 +3,8 @@ package headsync
import (
"context"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/ldiff"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"testing"

2
common/pkg/acl/account/accountdata.go → common/commonspace/object/accountdata/accountdata.go
View file

@ -1,4 +1,4 @@
package account
package accountdata
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"

0
common/pkg/acl/aclrecordproto/aclreadkeyderive.go → common/commonspace/object/acl/aclrecordproto/aclreadkeyderive.go
View file

0
common/pkg/acl/aclrecordproto/aclrecord.pb.go → common/commonspace/object/acl/aclrecordproto/aclrecord.pb.go
View file

0
common/pkg/acl/aclrecordproto/protos/aclrecord.proto → common/commonspace/object/acl/aclrecordproto/protos/aclrecord.proto
View file

14
common/pkg/acl/list/aclrecordbuilder.go → common/commonspace/object/acl/list/aclrecordbuilder.go
View file

@ -1,9 +1,9 @@
package list
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cid"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cidutil"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
"github.com/gogo/protobuf/proto"
@ -17,10 +17,10 @@ type ACLRecordBuilder interface {
type aclRecordBuilder struct {
id string
keychain *common.Keychain
keychain *keychain.Keychain
}
func newACLRecordBuilder(id string, keychain *common.Keychain) ACLRecordBuilder {
func newACLRecordBuilder(id string, keychain *keychain.Keychain) ACLRecordBuilder {
return &aclRecordBuilder{
id: id,
keychain: keychain,
@ -149,7 +149,7 @@ func (a *aclRecordBuilder) ConvertFromRaw(rawIdRecord *aclrecordproto.RawACLReco
}
func verifyRaw(
keychain *common.Keychain,
keychain *keychain.Keychain,
rawRec *aclrecordproto.RawACLRecord,
recWithId *aclrecordproto.RawACLRecordWithId,
identity []byte) (err error) {
@ -169,7 +169,7 @@ func verifyRaw(
}
// verifying ID
if !cid.VerifyCID(recWithId.Payload, recWithId.Id) {
if !cidutil.VerifyCID(recWithId.Payload, recWithId.Id) {
err = ErrIncorrectCID
}
return

30
common/pkg/acl/list/aclrecordbuilder_test.go → common/commonspace/object/acl/list/aclrecordbuilder_test.go
View file

@ -1,25 +1,25 @@
package list
import (
account "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/acllistbuilder"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cid"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
acllistbuilder2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/testutils/acllistbuilder"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cidutil"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
"github.com/stretchr/testify/require"
"testing"
)
func TestAclRecordBuilder_BuildUserJoin(t *testing.T) {
st, err := acllistbuilder.NewListStorageWithTestName("userjoinexample.yml")
st, err := acllistbuilder2.NewListStorageWithTestName("userjoinexample.yml")
require.NoError(t, err, "building storage should not result in error")
keychain := st.(*acllistbuilder.ACLListStorageBuilder).GetKeychain()
identity := keychain.GeneratedIdentities["D"]
signPrivKey := keychain.SigningKeysByYAMLName["D"]
encPrivKey := keychain.EncryptionKeysByYAMLName["D"]
acc := &account.AccountData{
testKeychain := st.(*acllistbuilder2.ACLListStorageBuilder).GetKeychain()
identity := testKeychain.GeneratedIdentities["D"]
signPrivKey := testKeychain.SigningKeysByYAMLName["D"]
encPrivKey := testKeychain.EncryptionKeysByYAMLName["D"]
acc := &accountdata.AccountData{
Identity: []byte(identity),
SignKey: signPrivKey,
EncKey: encPrivKey,
@ -27,17 +27,17 @@ func TestAclRecordBuilder_BuildUserJoin(t *testing.T) {
aclList, err := BuildACLListWithIdentity(acc, st)
require.NoError(t, err, "building acl list should be without error")
recordBuilder := newACLRecordBuilder(aclList.ID(), common.NewKeychain())
rk, err := keychain.GetKey("key.Read.EncKey").(*acllistbuilder.SymKey).Key.Raw()
recordBuilder := newACLRecordBuilder(aclList.ID(), keychain.NewKeychain())
rk, err := testKeychain.GetKey("key.Read.EncKey").(*acllistbuilder2.SymKey).Key.Raw()
require.NoError(t, err)
privKey, err := keychain.GetKey("key.Sign.Onetime1").(signingkey.PrivKey).Raw()
privKey, err := testKeychain.GetKey("key.Sign.Onetime1").(signingkey.PrivKey).Raw()
require.NoError(t, err)
userJoin, err := recordBuilder.BuildUserJoin(privKey, rk, aclList.ACLState())
require.NoError(t, err)
marshalledJoin, err := userJoin.Marshal()
require.NoError(t, err)
id, err := cid.NewCIDFromBytes(marshalledJoin)
id, err := cidutil.NewCIDFromBytes(marshalledJoin)
require.NoError(t, err)
rawRec := &aclrecordproto.RawACLRecordWithId{
Payload: marshalledJoin,

96
common/pkg/acl/list/aclstate.go → common/commonspace/object/acl/list/aclstate.go
View file

@ -5,8 +5,8 @@ import (
"errors"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
aclrecordproto2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
@ -18,31 +18,33 @@ import (
var log = logger.NewNamed("acllist").Sugar()
var ErrNoSuchUser = errors.New("no such user")
var ErrFailedToDecrypt = errors.New("failed to decrypt key")
var ErrUserRemoved = errors.New("user was removed from the document")
var ErrDocumentForbidden = errors.New("your user was forbidden access to the document")
var ErrUserAlreadyExists = errors.New("user already exists")
var ErrNoSuchRecord = errors.New("no such record")
var ErrNoSuchInvite = errors.New("no such invite")
var ErrOldInvite = errors.New("invite is too old")
var ErrInsufficientPermissions = errors.New("insufficient permissions")
var ErrNoReadKey = errors.New("acl state doesn't have a read key")
var ErrInvalidSignature = errors.New("signature is invalid")
var ErrIncorrectRoot = errors.New("incorrect root")
var ErrIncorrectRecordSequence = errors.New("incorrect prev id of a record")
var (
ErrNoSuchUser = errors.New("no such user")
ErrFailedToDecrypt = errors.New("failed to decrypt key")
ErrUserRemoved = errors.New("user was removed from the document")
ErrDocumentForbidden = errors.New("your user was forbidden access to the document")
ErrUserAlreadyExists = errors.New("user already exists")
ErrNoSuchRecord = errors.New("no such record")
ErrNoSuchInvite = errors.New("no such invite")
ErrOldInvite = errors.New("invite is too old")
ErrInsufficientPermissions = errors.New("insufficient permissions")
ErrNoReadKey = errors.New("acl state doesn't have a read key")
ErrInvalidSignature = errors.New("signature is invalid")
ErrIncorrectRoot = errors.New("incorrect root")
ErrIncorrectRecordSequence = errors.New("incorrect prev id of a record")
)
type UserPermissionPair struct {
Identity string
Permission aclrecordproto.ACLUserPermissions
Permission aclrecordproto2.ACLUserPermissions
}
type ACLState struct {
id string
currentReadKeyHash uint64
userReadKeys map[uint64]*symmetric.Key
userStates map[string]*aclrecordproto.ACLUserState
userInvites map[string]*aclrecordproto.ACLUserInvite
userStates map[string]*aclrecordproto2.ACLUserState
userInvites map[string]*aclrecordproto2.ACLUserInvite
encryptionKey encryptionkey.PrivKey
signingKey signingkey.PrivKey
totalReadKeys int
@ -51,7 +53,7 @@ type ACLState struct {
permissionsAtRecord map[string][]UserPermissionPair
lastRecordId string
keychain *common.Keychain
keychain *keychain.Keychain
}
func newACLStateWithKeys(
@ -68,8 +70,8 @@ func newACLStateWithKeys(
signingKey: signingKey,
encryptionKey: encryptionKey,
userReadKeys: make(map[uint64]*symmetric.Key),
userStates: make(map[string]*aclrecordproto.ACLUserState),
userInvites: make(map[string]*aclrecordproto.ACLUserInvite),
userStates: make(map[string]*aclrecordproto2.ACLUserState),
userInvites: make(map[string]*aclrecordproto2.ACLUserInvite),
permissionsAtRecord: make(map[string][]UserPermissionPair),
}, nil
}
@ -78,8 +80,8 @@ func newACLState(id string) *ACLState {
return &ACLState{
id: id,
userReadKeys: make(map[uint64]*symmetric.Key),
userStates: make(map[string]*aclrecordproto.ACLUserState),
userInvites: make(map[string]*aclrecordproto.ACLUserInvite),
userStates: make(map[string]*aclrecordproto2.ACLUserState),
userInvites: make(map[string]*aclrecordproto2.ACLUserInvite),
permissionsAtRecord: make(map[string][]UserPermissionPair),
}
}
@ -126,7 +128,7 @@ func (st *ACLState) applyRecord(record *ACLRecord) (err error) {
return
}
if record.Id == st.id {
root, ok := record.Model.(*aclrecordproto.ACLRoot)
root, ok := record.Model.(*aclrecordproto2.ACLRoot)
if !ok {
return ErrIncorrectRoot
}
@ -135,14 +137,14 @@ func (st *ACLState) applyRecord(record *ACLRecord) (err error) {
return
}
st.permissionsAtRecord[record.Id] = []UserPermissionPair{
{Identity: string(root.Identity), Permission: aclrecordproto.ACLUserPermissions_Admin},
{Identity: string(root.Identity), Permission: aclrecordproto2.ACLUserPermissions_Admin},
}
return
}
aclData := &aclrecordproto.ACLData{}
aclData := &aclrecordproto2.ACLData{}
if record.Model != nil {
aclData = record.Model.(*aclrecordproto.ACLData)
aclData = record.Model.(*aclrecordproto2.ACLData)
} else {
err = proto.Unmarshal(record.Data, aclData)
if err != nil {
@ -170,7 +172,7 @@ func (st *ACLState) applyRecord(record *ACLRecord) (err error) {
return
}
func (st *ACLState) applyRoot(root *aclrecordproto.ACLRoot) (err error) {
func (st *ACLState) applyRoot(root *aclrecordproto2.ACLRoot) (err error) {
if st.signingKey != nil && st.encryptionKey != nil && st.identity == string(root.Identity) {
err = st.saveReadKeyFromRoot(root)
if err != nil {
@ -179,10 +181,10 @@ func (st *ACLState) applyRoot(root *aclrecordproto.ACLRoot) (err error) {
}
// adding user to the list
userState := &aclrecordproto.ACLUserState{
userState := &aclrecordproto2.ACLUserState{
Identity: root.Identity,
EncryptionKey: root.EncryptionKey,
Permissions: aclrecordproto.ACLUserPermissions_Admin,
Permissions: aclrecordproto2.ACLUserPermissions_Admin,
}
st.currentReadKeyHash = root.CurrentReadKeyHash
st.userStates[string(root.Identity)] = userState
@ -190,7 +192,7 @@ func (st *ACLState) applyRoot(root *aclrecordproto.ACLRoot) (err error) {
return
}
func (st *ACLState) saveReadKeyFromRoot(root *aclrecordproto.ACLRoot) (err error) {
func (st *ACLState) saveReadKeyFromRoot(root *aclrecordproto2.ACLRoot) (err error) {
var readKey *symmetric.Key
if len(root.GetDerivationScheme()) != 0 {
var encPrivKey []byte
@ -204,7 +206,7 @@ func (st *ACLState) saveReadKeyFromRoot(root *aclrecordproto.ACLRoot) (err error
return
}
readKey, err = aclrecordproto.ACLReadKeyDerive(signPrivKey, encPrivKey)
readKey, err = aclrecordproto2.ACLReadKeyDerive(signPrivKey, encPrivKey)
if err != nil {
return
}
@ -228,7 +230,7 @@ func (st *ACLState) saveReadKeyFromRoot(root *aclrecordproto.ACLRoot) (err error
return
}
func (st *ACLState) applyChangeData(changeData *aclrecordproto.ACLData, hash uint64, identity []byte) (err error) {
func (st *ACLState) applyChangeData(changeData *aclrecordproto2.ACLData, hash uint64, identity []byte) (err error) {
defer func() {
if err != nil {
return
@ -246,7 +248,7 @@ func (st *ACLState) applyChangeData(changeData *aclrecordproto.ACLData, hash uin
return
}
if !st.HasPermission(identity, aclrecordproto.ACLUserPermissions_Admin) {
if !st.HasPermission(identity, aclrecordproto2.ACLUserPermissions_Admin) {
err = fmt.Errorf("user %s must have admin permissions", identity)
return
}
@ -262,7 +264,7 @@ func (st *ACLState) applyChangeData(changeData *aclrecordproto.ACLData, hash uin
return nil
}
func (st *ACLState) applyChangeContent(ch *aclrecordproto.ACLContentValue) error {
func (st *ACLState) applyChangeContent(ch *aclrecordproto2.ACLContentValue) error {
switch {
case ch.GetUserPermissionChange() != nil:
return st.applyUserPermissionChange(ch.GetUserPermissionChange())
@ -279,7 +281,7 @@ func (st *ACLState) applyChangeContent(ch *aclrecordproto.ACLContentValue) error
}
}
func (st *ACLState) applyUserPermissionChange(ch *aclrecordproto.ACLUserPermissionChange) error {
func (st *ACLState) applyUserPermissionChange(ch *aclrecordproto2.ACLUserPermissionChange) error {
chIdentity := string(ch.Identity)
state, exists := st.userStates[chIdentity]
if !exists {
@ -290,12 +292,12 @@ func (st *ACLState) applyUserPermissionChange(ch *aclrecordproto.ACLUserPermissi
return nil
}
func (st *ACLState) applyUserInvite(ch *aclrecordproto.ACLUserInvite) error {
func (st *ACLState) applyUserInvite(ch *aclrecordproto2.ACLUserInvite) error {
st.userInvites[string(ch.AcceptPublicKey)] = ch
return nil
}
func (st *ACLState) applyUserJoin(ch *aclrecordproto.ACLUserJoin) error {
func (st *ACLState) applyUserJoin(ch *aclrecordproto2.ACLUserJoin) error {
invite, exists := st.userInvites[string(ch.AcceptPubKey)]
if !exists {
return fmt.Errorf("no such invite with such public key %s", keys.EncodeBytesToString(ch.AcceptPubKey))
@ -334,7 +336,7 @@ func (st *ACLState) applyUserJoin(ch *aclrecordproto.ACLUserJoin) error {
}
// adding user to the list
userState := &aclrecordproto.ACLUserState{
userState := &aclrecordproto2.ACLUserState{
Identity: ch.Identity,
EncryptionKey: ch.EncryptionKey,
Permissions: invite.Permissions,
@ -343,13 +345,13 @@ func (st *ACLState) applyUserJoin(ch *aclrecordproto.ACLUserJoin) error {
return nil
}
func (st *ACLState) applyUserAdd(ch *aclrecordproto.ACLUserAdd) error {
func (st *ACLState) applyUserAdd(ch *aclrecordproto2.ACLUserAdd) error {
chIdentity := string(ch.Identity)
if _, exists := st.userStates[chIdentity]; exists {
return ErrUserAlreadyExists
}
st.userStates[chIdentity] = &aclrecordproto.ACLUserState{
st.userStates[chIdentity] = &aclrecordproto2.ACLUserState{
Identity: ch.Identity,
EncryptionKey: ch.EncryptionKey,
Permissions: ch.Permissions,
@ -369,7 +371,7 @@ func (st *ACLState) applyUserAdd(ch *aclrecordproto.ACLUserAdd) error {
return nil
}
func (st *ACLState) applyUserRemove(ch *aclrecordproto.ACLUserRemove) error {
func (st *ACLState) applyUserRemove(ch *aclrecordproto2.ACLUserRemove) error {
chIdentity := string(ch.Identity)
if chIdentity == st.identity {
return ErrDocumentForbidden
@ -413,7 +415,7 @@ func (st *ACLState) decryptReadKeyAndHash(msg []byte) (*symmetric.Key, uint64, e
return key, hasher.Sum64(), nil
}
func (st *ACLState) HasPermission(identity []byte, permission aclrecordproto.ACLUserPermissions) bool {
func (st *ACLState) HasPermission(identity []byte, permission aclrecordproto2.ACLUserPermissions) bool {
state, exists := st.userStates[string(identity)]
if !exists {
return false
@ -422,22 +424,22 @@ func (st *ACLState) HasPermission(identity []byte, permission aclrecordproto.ACL
return state.Permissions == permission
}
func (st *ACLState) isUserJoin(data *aclrecordproto.ACLData) bool {
func (st *ACLState) isUserJoin(data *aclrecordproto2.ACLData) bool {
// if we have a UserJoin, then it should always be the first one applied
return data.GetAclContent() != nil && data.GetAclContent()[0].GetUserJoin() != nil
}
func (st *ACLState) isUserAdd(data *aclrecordproto.ACLData, identity []byte) bool {
func (st *ACLState) isUserAdd(data *aclrecordproto2.ACLData, identity []byte) bool {
// if we have a UserAdd, then it should always be the first one applied
userAdd := data.GetAclContent()[0].GetUserAdd()
return data.GetAclContent() != nil && userAdd != nil && bytes.Compare(userAdd.GetIdentity(), identity) == 0
}
func (st *ACLState) UserStates() map[string]*aclrecordproto.ACLUserState {
func (st *ACLState) UserStates() map[string]*aclrecordproto2.ACLUserState {
return st.userStates
}
func (st *ACLState) Invite(acceptPubKey []byte) (invite *aclrecordproto.ACLUserInvite, err error) {
func (st *ACLState) Invite(acceptPubKey []byte) (invite *aclrecordproto2.ACLUserInvite, err error) {
invite, exists := st.userInvites[string(acceptPubKey)]
if !exists {
err = ErrNoSuchInvite

4
common/pkg/acl/list/aclstatebuilder.go → common/commonspace/object/acl/list/aclstatebuilder.go
View file

@ -1,7 +1,7 @@
package list
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
)
@ -12,7 +12,7 @@ type aclStateBuilder struct {
id string
}
func newACLStateBuilderWithIdentity(accountData *account.AccountData) *aclStateBuilder {
func newACLStateBuilderWithIdentity(accountData *accountdata.AccountData) *aclStateBuilder {
return &aclStateBuilder{
signPrivKey: accountData.SignKey,
encPrivKey: accountData.EncKey,

91
common/pkg/acl/list/list.go → common/commonspace/object/acl/list/list.go
View file

@ -1,23 +1,20 @@
//go:generate mockgen -destination mock_list/mock_list.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list ACLList
//go:generate mockgen -destination mock_list/mock_list.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list ACLList
package list
import (
"context"
"errors"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/account"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/accountdata"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
"sync"
)
type IterFunc = func(record *ACLRecord) (IsContinue bool)
var (
ErrIncorrectCID = errors.New("incorrect CID")
ErrInconsistent = errors.New("inconsistent record")
)
var ErrIncorrectCID = errors.New("incorrect CID")
type RWLocker interface {
sync.Locker
@ -28,7 +25,7 @@ type RWLocker interface {
type ACLList interface {
RWLocker
ID() string
Root() *aclrecordproto.ACLRoot
Root() *aclrecordproto.RawACLRecordWithId
Records() []*ACLRecord
ACLState() *ACLState
IsAfter(first string, second string) (bool, error)
@ -43,39 +40,30 @@ type ACLList interface {
}
type aclList struct {
root *aclrecordproto.ACLRoot
root *aclrecordproto.RawACLRecordWithId
records []*ACLRecord
indexes map[string]int
id string
recBuilder ACLRecordBuilder
builder *aclStateBuilder
stateBuilder *aclStateBuilder
recordBuilder ACLRecordBuilder
aclState *ACLState
keychain *common.Keychain
keychain *keychain.Keychain
storage liststorage.ListStorage
sync.RWMutex
}
func BuildACLListWithIdentity(acc *account.AccountData, storage storage.ListStorage) (ACLList, error) {
func BuildACLListWithIdentity(acc *accountdata.AccountData, storage liststorage.ListStorage) (ACLList, error) {
builder := newACLStateBuilderWithIdentity(acc)
return build(storage.Id(), builder, newACLRecordBuilder(storage.Id(), common.NewKeychain()), storage)
return build(storage.Id(), builder, newACLRecordBuilder(storage.Id(), keychain.NewKeychain()), storage)
}
func BuildACLList(storage storage.ListStorage) (ACLList, error) {
return build(storage.Id(), newACLStateBuilder(), newACLRecordBuilder(storage.Id(), common.NewKeychain()), storage)
func BuildACLList(storage liststorage.ListStorage) (ACLList, error) {
return build(storage.Id(), newACLStateBuilder(), newACLRecordBuilder(storage.Id(), keychain.NewKeychain()), storage)
}
func build(id string, stateBuilder *aclStateBuilder, recBuilder ACLRecordBuilder, storage storage.ListStorage) (list ACLList, err error) {
// TODO: need to add context here
rootWithId, err := storage.Root()
if err != nil {
return
}
aclRecRoot, err := recBuilder.ConvertFromRaw(rootWithId)
if err != nil {
return
}
func build(id string, stateBuilder *aclStateBuilder, recBuilder ACLRecordBuilder, storage liststorage.ListStorage) (list ACLList, err error) {
head, err := storage.Head()
if err != nil {
return
@ -92,7 +80,7 @@ func build(id string, stateBuilder *aclStateBuilder, recBuilder ACLRecordBuilder
}
records := []*ACLRecord{record}
for record.PrevId != "" && record.PrevId != id {
for record.PrevId != "" {
rawRecordWithId, err = storage.GetRawRecord(context.Background(), record.PrevId)
if err != nil {
return
@ -104,8 +92,6 @@ func build(id string, stateBuilder *aclStateBuilder, recBuilder ACLRecordBuilder
}
records = append(records, record)
}
// adding root in the end, because we already parsed it
records = append(records, aclRecRoot)
indexes := make(map[string]int)
for i, j := 0, len(records)-1; i < j; i, j = i+1, j-1 {
@ -124,13 +110,20 @@ func build(id string, stateBuilder *aclStateBuilder, recBuilder ACLRecordBuilder
return
}
// TODO: check if this is correct (raw model instead of unmarshalled)
rootWithId, err := storage.Root()
if err != nil {
return
}
list = &aclList{
root: aclRecRoot.Model.(*aclrecordproto.ACLRoot),
root: rootWithId,
records: records,
indexes: indexes,
builder: stateBuilder,
recBuilder: recBuilder,
stateBuilder: stateBuilder,
recordBuilder: recBuilder,
aclState: state,
storage: storage,
id: id,
}
return
@ -144,34 +137,30 @@ func (a *aclList) AddRawRecord(rawRec *aclrecordproto.RawACLRecordWithId) (added
if _, ok := a.indexes[rawRec.Id]; ok {
return
}
record, err := a.recBuilder.ConvertFromRaw(rawRec)
record, err := a.recordBuilder.ConvertFromRaw(rawRec)
if err != nil {
return
}
var lastId string
if len(a.records) > 0 {
lastId = a.records[len(a.records)-1].Id
}
if record.PrevId != lastId {
return false, ErrInconsistent
if err = a.aclState.applyRecord(record); err != nil {
return
}
a.records = append(a.records, record)
a.indexes[record.Id] = len(a.records) - 1
if err = a.storage.AddRawRecord(context.Background(), rawRec); err != nil {
return
}
if err = a.storage.SetHead(rawRec.Id); err != nil {
return
}
return true, nil
}
func (a *aclList) IsValidNext(rawRec *aclrecordproto.RawACLRecordWithId) (err error) {
rec, err := a.recBuilder.ConvertFromRaw(rawRec)
_, err = a.recordBuilder.ConvertFromRaw(rawRec)
if err != nil {
return
}
var lastId string
if len(a.records) > 0 {
lastId = a.records[len(a.records)-1].Id
}
if rec.PrevId != lastId {
return ErrInconsistent
}
// TODO: change state and add "check" method for records
return
}
@ -179,7 +168,7 @@ func (a *aclList) ID() string {
return a.id
}
func (a *aclList) Root() *aclrecordproto.ACLRoot {
func (a *aclList) Root() *aclrecordproto.RawACLRecordWithId {
return a.root
}

4
common/pkg/acl/list/list_test.go → common/commonspace/object/acl/list/list_test.go
View file

@ -1,8 +1,8 @@
package list
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/acllistbuilder"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/testutils/acllistbuilder"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"testing"

6
common/pkg/acl/list/mock_list/mock_list.go → common/commonspace/object/acl/list/mock_list/mock_list.go
View file

@ -1,5 +1,5 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list (interfaces: ACLList)
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list (interfaces: ACLList)
// Package mock_list is a generated GoMock package.
package mock_list
@ -7,8 +7,8 @@ package mock_list
import (
reflect "reflect"
aclrecordproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
list "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
aclrecordproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
list "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
gomock "github.com/golang/mock/gomock"
)

0
common/pkg/acl/list/record.go → common/commonspace/object/acl/list/record.go
View file

78
common/commonspace/object/acl/liststorage/inmemory.go Normal file
View file

@ -0,0 +1,78 @@
package liststorage
import (
"context"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"sync"
)
type inMemoryACLListStorage struct {
id string
root *aclrecordproto.RawACLRecordWithId
head string
records map[string]*aclrecordproto.RawACLRecordWithId
sync.RWMutex
}
func NewInMemoryACLListStorage(
id string,
records []*aclrecordproto.RawACLRecordWithId) (ListStorage, error) {
allRecords := make(map[string]*aclrecordproto.RawACLRecordWithId)
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() (*aclrecordproto.RawACLRecordWithId, 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 *aclrecordproto.RawACLRecordWithId) error {
t.Lock()
defer t.Unlock()
// TODO: better to do deep copy
t.records[record.Id] = record
return nil
}
func (t *inMemoryACLListStorage) GetRawRecord(ctx context.Context, recordId string) (*aclrecordproto.RawACLRecordWithId, 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)
}

14
common/pkg/acl/storage/liststorage.go → common/commonspace/object/acl/liststorage/liststorage.go
View file

@ -1,15 +1,17 @@
//go:generate mockgen -destination mock_storage/mock_storage.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage ListStorage,TreeStorage
package storage
//go:generate mockgen -destination mock_liststorage/mock_liststorage.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage ListStorage
package liststorage
import (
"context"
"errors"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
)
var ErrUnknownACLId = errors.New("acl does not exist")
var ErrACLExists = errors.New("acl already exists")
var ErrUnknownRecord = errors.New("record doesn't exist")
var (
ErrUnknownACLId = errors.New("acl does not exist")
ErrACLExists = errors.New("acl already exists")
ErrUnknownRecord = errors.New("record doesn't exist")
)
type ListStorage interface {
Id() string

123
common/commonspace/object/acl/liststorage/mock_liststorage/mock_liststorage.go Normal file
View file

@ -0,0 +1,123 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage (interfaces: ListStorage)
// Package mock_liststorage is a generated GoMock package.
package mock_liststorage
import (
context "context"
reflect "reflect"
aclrecordproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
gomock "github.com/golang/mock/gomock"
)
// MockListStorage is a mock of ListStorage interface.
type MockListStorage struct {
ctrl *gomock.Controller
recorder *MockListStorageMockRecorder
}
// 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(arg0 context.Context, arg1 *aclrecordproto.RawACLRecordWithId) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawRecord", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
// AddRawRecord indicates an expected call of AddRawRecord.
func (mr *MockListStorageMockRecorder) AddRawRecord(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockListStorage)(nil).AddRawRecord), arg0, arg1)
}
// GetRawRecord mocks base method.
func (m *MockListStorage) GetRawRecord(arg0 context.Context, arg1 string) (*aclrecordproto.RawACLRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "GetRawRecord", arg0, arg1)
ret0, _ := ret[0].(*aclrecordproto.RawACLRecordWithId)
ret1, _ := ret[1].(error)
return ret0, ret1
}
// GetRawRecord indicates an expected call of GetRawRecord.
func (mr *MockListStorageMockRecorder) GetRawRecord(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRawRecord", reflect.TypeOf((*MockListStorage)(nil).GetRawRecord), arg0, arg1)
}
// 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() (*aclrecordproto.RawACLRecordWithId, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Root")
ret0, _ := ret[0].(*aclrecordproto.RawACLRecordWithId)
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(arg0 string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "SetHead", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// SetHead indicates an expected call of SetHead.
func (mr *MockListStorageMockRecorder) SetHead(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHead", reflect.TypeOf((*MockListStorage)(nil).SetHead), arg0)
}

10
common/commonspace/syncacl/syncacl.go → common/commonspace/object/acl/syncacl/syncacl.go
View file

@ -1,18 +1,18 @@
package syncacl
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice/synchandler"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync/synchandler"
)
type SyncACL struct {
list.ACLList
synchandler.SyncHandler
streamPool syncservice.StreamPool
streamPool objectsync.StreamPool
}
func NewSyncACL(aclList list.ACLList, streamPool syncservice.StreamPool) *SyncACL {
func NewSyncACL(aclList list.ACLList, streamPool objectsync.StreamPool) *SyncACL {
return &SyncACL{
ACLList: aclList,
SyncHandler: nil,

4
common/commonspace/syncacl/syncaclhandler.go → common/commonspace/object/acl/syncacl/syncaclhandler.go
View file

@ -3,9 +3,9 @@ package syncacl
import (
"context"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
)
type syncAclHandler struct {

32
common/pkg/acl/testutils/acllistbuilder/keychain.go → common/commonspace/object/acl/testutils/acllistbuilder/keychain.go
View file

@ -1,10 +1,10 @@
package acllistbuilder
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys"
encryptionkey2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
signingkey2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
"hash/fnv"
"strings"
@ -16,9 +16,9 @@ type SymKey struct {
}
type YAMLKeychain struct {
SigningKeysByYAMLName map[string]signingkey2.PrivKey
SigningKeysByRealIdentity map[string]signingkey2.PrivKey
EncryptionKeysByYAMLName map[string]encryptionkey2.PrivKey
SigningKeysByYAMLName map[string]signingkey.PrivKey
SigningKeysByRealIdentity map[string]signingkey.PrivKey
EncryptionKeysByYAMLName map[string]encryptionkey.PrivKey
ReadKeysByYAMLName map[string]*SymKey
ReadKeysByHash map[uint64]*SymKey
GeneratedIdentities map[string]string
@ -26,9 +26,9 @@ type YAMLKeychain struct {
func NewKeychain() *YAMLKeychain {
return &YAMLKeychain{
SigningKeysByYAMLName: map[string]signingkey2.PrivKey{},
SigningKeysByRealIdentity: map[string]signingkey2.PrivKey{},
EncryptionKeysByYAMLName: map[string]encryptionkey2.PrivKey{},
SigningKeysByYAMLName: map[string]signingkey.PrivKey{},
SigningKeysByRealIdentity: map[string]signingkey.PrivKey{},
EncryptionKeysByYAMLName: map[string]encryptionkey.PrivKey{},
GeneratedIdentities: map[string]string{},
ReadKeysByYAMLName: map[string]*SymKey{},
ReadKeysByHash: map[uint64]*SymKey{},
@ -54,16 +54,16 @@ func (k *YAMLKeychain) AddEncryptionKey(key *Key) {
return
}
var (
newPrivKey encryptionkey2.PrivKey
newPrivKey encryptionkey.PrivKey
err error
)
if key.Value == "generated" {
newPrivKey, _, err = encryptionkey2.GenerateRandomRSAKeyPair(2048)
newPrivKey, _, err = encryptionkey.GenerateRandomRSAKeyPair(2048)
if err != nil {
panic(err)
}
} else {
newPrivKey, err = keys.DecodeKeyFromString(key.Value, encryptionkey2.NewEncryptionRsaPrivKeyFromBytes, nil)
newPrivKey, err = keys.DecodeKeyFromString(key.Value, encryptionkey.NewEncryptionRsaPrivKeyFromBytes, nil)
if err != nil {
panic(err)
}
@ -76,17 +76,17 @@ func (k *YAMLKeychain) AddSigningKey(key *Key) {
return
}
var (
newPrivKey signingkey2.PrivKey
pubKey signingkey2.PubKey
newPrivKey signingkey.PrivKey
pubKey signingkey.PubKey
err error
)
if key.Value == "generated" {
newPrivKey, pubKey, err = signingkey2.GenerateRandomEd25519KeyPair()
newPrivKey, pubKey, err = signingkey.GenerateRandomEd25519KeyPair()
if err != nil {
panic(err)
}
} else {
newPrivKey, err = keys.DecodeKeyFromString(key.Value, signingkey2.NewSigningEd25519PrivKeyFromBytes, nil)
newPrivKey, err = keys.DecodeKeyFromString(key.Value, signingkey.NewSigningEd25519PrivKeyFromBytes, nil)
if err != nil {
panic(err)
}

214
common/pkg/acl/testutils/acllistbuilder/liststoragebuilder.go → common/commonspace/object/acl/testutils/acllistbuilder/liststoragebuilder.go
View file

@ -3,13 +3,13 @@ package acllistbuilder
import (
"context"
"fmt"
aclrecordproto2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/yamltests"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cid"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/liststorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/testutils/yamltests"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cidutil"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/encryptionkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
"hash/fnv"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
"io/ioutil"
"path"
"time"
@ -19,25 +19,17 @@ import (
)
type ACLListStorageBuilder struct {
aclList string
records []*aclrecordproto2.ACLRecord
rawRecords []*aclrecordproto2.RawACLRecordWithId
indexes map[string]int
liststorage.ListStorage
keychain *YAMLKeychain
rawRoot *aclrecordproto2.RawACLRecordWithId
root *aclrecordproto2.ACLRoot
id string
}
func NewACLListStorageBuilder(keychain *YAMLKeychain) *ACLListStorageBuilder {
return &ACLListStorageBuilder{
records: make([]*aclrecordproto2.ACLRecord, 0),
indexes: make(map[string]int),
keychain: keychain,
}
}
func NewListStorageWithTestName(name string) (storage.ListStorage, error) {
func NewListStorageWithTestName(name string) (liststorage.ListStorage, error) {
filePath := path.Join(yamltests.Path(), name)
return NewACLListStorageBuilderFromFile(filePath)
}
@ -60,7 +52,7 @@ func NewACLListStorageBuilderFromFile(file string) (*ACLListStorageBuilder, erro
return tb, nil
}
func (t *ACLListStorageBuilder) createRaw(rec proto.Marshaler, identity []byte) *aclrecordproto2.RawACLRecordWithId {
func (t *ACLListStorageBuilder) createRaw(rec proto.Marshaler, identity []byte) *aclrecordproto.RawACLRecordWithId {
protoMarshalled, err := rec.Marshal()
if err != nil {
panic("should be able to marshal final acl message!")
@ -71,7 +63,7 @@ func (t *ACLListStorageBuilder) createRaw(rec proto.Marshaler, identity []byte)
panic("should be able to sign final acl message!")
}
rawRec := &aclrecordproto2.RawACLRecord{
rawRec := &aclrecordproto.RawACLRecord{
Payload: protoMarshalled,
Signature: signature,
}
@ -81,96 +73,64 @@ func (t *ACLListStorageBuilder) createRaw(rec proto.Marshaler, identity []byte)
panic(err)
}
id, _ := cid.NewCIDFromBytes(rawMarshalled)
id, _ := cidutil.NewCIDFromBytes(rawMarshalled)
return &aclrecordproto2.RawACLRecordWithId{
return &aclrecordproto.RawACLRecordWithId{
Payload: rawMarshalled,
Id: id,
}
}
func (t *ACLListStorageBuilder) Head() (string, error) {
l := len(t.records)
if l > 0 {
return t.rawRecords[l-1].Id, nil
}
return t.rawRoot.Id, nil
}
func (t *ACLListStorageBuilder) SetHead(headId string) error {
panic("SetHead is not implemented")
}
func (t *ACLListStorageBuilder) Root() (*aclrecordproto2.RawACLRecordWithId, error) {
return t.rawRoot, nil
}
func (t *ACLListStorageBuilder) GetRawRecord(ctx context.Context, id string) (*aclrecordproto2.RawACLRecordWithId, error) {
recIdx, ok := t.indexes[id]
if !ok {
if id == t.rawRoot.Id {
return t.rawRoot, nil
}
return nil, fmt.Errorf("no such record")
}
return t.rawRecords[recIdx], nil
}
func (t *ACLListStorageBuilder) AddRawRecord(ctx context.Context, rec *aclrecordproto2.RawACLRecordWithId) error {
panic("implement me")
}
func (t *ACLListStorageBuilder) Id() string {
return t.id
}
func (t *ACLListStorageBuilder) GetRawRecords() []*aclrecordproto2.RawACLRecordWithId {
return t.rawRecords
}
func (t *ACLListStorageBuilder) GetKeychain() *YAMLKeychain {
return t.keychain
}
func (t *ACLListStorageBuilder) Parse(tree *YMLList) {
func (t *ACLListStorageBuilder) Parse(l *YMLList) {
// Just to clarify - we are generating new identities for the ones that
// are specified in the yml file, because our identities should be Ed25519
// the same thing is happening for the encryption keys
t.keychain.ParseKeys(&tree.Keys)
t.parseRoot(tree.Root)
prevId := t.id
for idx, rec := range tree.Records {
t.keychain.ParseKeys(&l.Keys)
rawRoot := t.parseRoot(l.Root)
var err error
t.ListStorage, err = liststorage.NewInMemoryACLListStorage(rawRoot.Id, []*aclrecordproto.RawACLRecordWithId{rawRoot})
if err != nil {
panic(err)
}
prevId := rawRoot.Id
for _, rec := range l.Records {
newRecord := t.parseRecord(rec, prevId)
rawRecord := t.createRaw(newRecord, newRecord.Identity)
t.records = append(t.records, newRecord)
t.rawRecords = append(t.rawRecords, rawRecord)
t.indexes[rawRecord.Id] = idx
err = t.AddRawRecord(context.Background(), rawRecord)
if err != nil {
panic(err)
}
prevId = rawRecord.Id
}
t.SetHead(prevId)
}
func (t *ACLListStorageBuilder) parseRecord(rec *Record, prevId string) *aclrecordproto2.ACLRecord {
func (t *ACLListStorageBuilder) parseRecord(rec *Record, prevId string) *aclrecordproto.ACLRecord {
k := t.keychain.GetKey(rec.ReadKey).(*SymKey)
var aclChangeContents []*aclrecordproto2.ACLContentValue
var aclChangeContents []*aclrecordproto.ACLContentValue
for _, ch := range rec.AclChanges {
aclChangeContent := t.parseACLChange(ch)
aclChangeContents = append(aclChangeContents, aclChangeContent)
}
data := &aclrecordproto2.ACLData{
data := &aclrecordproto.ACLData{
AclContent: aclChangeContents,
}
bytes, _ := data.Marshal()
return &aclrecordproto2.ACLRecord{
return &aclrecordproto.ACLRecord{
PrevId: prevId,
Identity: []byte(t.keychain.GetIdentity(rec.Identity)),
Data: bytes,
CurrentReadKeyHash: k.Hash,
Timestamp: time.Now().Unix(),
Timestamp: time.Now().UnixNano(),
}
}
func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecordproto2.ACLContentValue) {
func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecordproto.ACLContentValue) {
switch {
case ch.UserAdd != nil:
add := ch.UserAdd
@ -178,12 +138,12 @@ func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecord
encKey := t.keychain.GetKey(add.EncryptionKey).(encryptionkey.PrivKey)
rawKey, _ := encKey.GetPublic().Raw()
convCh = &aclrecordproto2.ACLContentValue{
Value: &aclrecordproto2.ACLContentValue_UserAdd{
UserAdd: &aclrecordproto2.ACLUserAdd{
convCh = &aclrecordproto.ACLContentValue{
Value: &aclrecordproto.ACLContentValue_UserAdd{
UserAdd: &aclrecordproto.ACLUserAdd{
Identity: []byte(t.keychain.GetIdentity(add.Identity)),
EncryptionKey: rawKey,
EncryptedReadKeys: t.encryptReadKeys(add.EncryptedReadKeys, encKey),
EncryptedReadKeys: t.encryptReadKeysWithPubKey(add.EncryptedReadKeys, encKey),
Permissions: t.convertPermission(add.Permission),
},
},
@ -191,52 +151,50 @@ func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecord
case ch.UserJoin != nil:
join := ch.UserJoin
encKey := t.keychain.
GetKey(join.EncryptionKey).(encryptionkey.PrivKey)
encKey := t.keychain.GetKey(join.EncryptionKey).(encryptionkey.PrivKey)
rawKey, _ := encKey.GetPublic().Raw()
idKey, _ := t.keychain.SigningKeysByYAMLIdentity[join.Identity].GetPublic().Raw()
signKey := t.keychain.GetKey(join.AcceptSignature).(signingkey.PrivKey)
idKey, _ := t.keychain.SigningKeysByYAMLName[join.Identity].GetPublic().Raw()
signKey := t.keychain.GetKey(join.AcceptKey).(signingkey.PrivKey)
signature, err := signKey.Sign(idKey)
if err != nil {
panic(err)
}
acceptPubKey, _ := signKey.GetPublic().Raw()
convCh = &aclrecordproto2.ACLContentValue{
Value: &aclrecordproto2.ACLContentValue_UserJoin{
UserJoin: &aclrecordproto2.ACLUserJoin{
convCh = &aclrecordproto.ACLContentValue{
Value: &aclrecordproto.ACLContentValue_UserJoin{
UserJoin: &aclrecordproto.ACLUserJoin{
Identity: []byte(t.keychain.GetIdentity(join.Identity)),
EncryptionKey: rawKey,
AcceptSignature: signature,
InviteId: join.InviteId,
EncryptedReadKeys: t.encryptReadKeys(join.EncryptedReadKeys, encKey),
AcceptPubKey: acceptPubKey,
EncryptedReadKeys: t.encryptReadKeysWithPubKey(join.EncryptedReadKeys, encKey),
},
},
}
case ch.UserInvite != nil:
invite := ch.UserInvite
rawAcceptKey, _ := t.keychain.GetKey(invite.AcceptKey).(signingkey.PrivKey).GetPublic().Raw()
encKey := t.keychain.
GetKey(invite.EncryptionKey).(encryptionkey.PrivKey)
rawEncKey, _ := encKey.GetPublic().Raw()
hash := t.keychain.GetKey(invite.EncryptionKey).(*SymKey).Hash
encKey := t.keychain.ReadKeysByHash[hash]
convCh = &aclrecordproto2.ACLContentValue{
Value: &aclrecordproto2.ACLContentValue_UserInvite{
UserInvite: &aclrecordproto2.ACLUserInvite{
convCh = &aclrecordproto.ACLContentValue{
Value: &aclrecordproto.ACLContentValue_UserInvite{
UserInvite: &aclrecordproto.ACLUserInvite{
AcceptPublicKey: rawAcceptKey,
EncryptPublicKey: rawEncKey,
EncryptedReadKeys: t.encryptReadKeys(invite.EncryptedReadKeys, encKey),
EncryptSymKeyHash: hash,
EncryptedReadKeys: t.encryptReadKeysWithSymKey(invite.EncryptedReadKeys, encKey.Key),
Permissions: t.convertPermission(invite.Permissions),
InviteId: invite.InviteId,
},
},
}
case ch.UserPermissionChange != nil:
permissionChange := ch.UserPermissionChange
convCh = &aclrecordproto2.ACLContentValue{
Value: &aclrecordproto2.ACLContentValue_UserPermissionChange{
UserPermissionChange: &aclrecordproto2.ACLUserPermissionChange{
convCh = &aclrecordproto.ACLContentValue{
Value: &aclrecordproto.ACLContentValue_UserPermissionChange{
UserPermissionChange: &aclrecordproto.ACLUserPermissionChange{
Identity: []byte(t.keychain.GetIdentity(permissionChange.Identity)),
Permissions: t.convertPermission(permissionChange.Permission),
},
@ -247,24 +205,24 @@ func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecord
newReadKey := t.keychain.GetKey(remove.NewReadKey).(*SymKey)
var replaces []*aclrecordproto2.ACLReadKeyReplace
var replaces []*aclrecordproto.ACLReadKeyReplace
for _, id := range remove.IdentitiesLeft {
encKey := t.keychain.EncryptionKeysByYAMLIdentity[id]
encKey := t.keychain.EncryptionKeysByYAMLName[id]
rawEncKey, _ := encKey.GetPublic().Raw()
encReadKey, err := encKey.GetPublic().Encrypt(newReadKey.Key.Bytes())
if err != nil {
panic(err)
}
replaces = append(replaces, &aclrecordproto2.ACLReadKeyReplace{
replaces = append(replaces, &aclrecordproto.ACLReadKeyReplace{
Identity: []byte(t.keychain.GetIdentity(id)),
EncryptionKey: rawEncKey,
EncryptedReadKey: encReadKey,
})
}
convCh = &aclrecordproto2.ACLContentValue{
Value: &aclrecordproto2.ACLContentValue_UserRemove{
UserRemove: &aclrecordproto2.ACLUserRemove{
convCh = &aclrecordproto.ACLContentValue{
Value: &aclrecordproto.ACLContentValue_UserRemove{
UserRemove: &aclrecordproto.ACLUserRemove{
Identity: []byte(t.keychain.GetIdentity(remove.RemovedIdentity)),
ReadKeyReplaces: replaces,
},
@ -278,7 +236,7 @@ func (t *ACLListStorageBuilder) parseACLChange(ch *ACLChange) (convCh *aclrecord
return convCh
}
func (t *ACLListStorageBuilder) encryptReadKeys(keys []string, encKey encryptionkey.PrivKey) (enc [][]byte) {
func (t *ACLListStorageBuilder) encryptReadKeysWithPubKey(keys []string, encKey encryptionkey.PrivKey) (enc [][]byte) {
for _, k := range keys {
realKey := t.keychain.GetKey(k).(*SymKey).Key.Bytes()
res, err := encKey.GetPublic().Encrypt(realKey)
@ -291,43 +249,47 @@ func (t *ACLListStorageBuilder) encryptReadKeys(keys []string, encKey encryption
return
}
func (t *ACLListStorageBuilder) convertPermission(perm string) aclrecordproto2.ACLUserPermissions {
func (t *ACLListStorageBuilder) encryptReadKeysWithSymKey(keys []string, key *symmetric.Key) (enc [][]byte) {
for _, k := range keys {
realKey := t.keychain.GetKey(k).(*SymKey).Key.Bytes()
res, err := key.Encrypt(realKey)
if err != nil {
panic(err)
}
enc = append(enc, res)
}
return
}
func (t *ACLListStorageBuilder) convertPermission(perm string) aclrecordproto.ACLUserPermissions {
switch perm {
case "admin":
return aclrecordproto2.ACLUserPermissions_Admin
return aclrecordproto.ACLUserPermissions_Admin
case "writer":
return aclrecordproto2.ACLUserPermissions_Writer
return aclrecordproto.ACLUserPermissions_Writer
case "reader":
return aclrecordproto2.ACLUserPermissions_Reader
return aclrecordproto.ACLUserPermissions_Reader
default:
panic(fmt.Sprintf("incorrect permission: %s", perm))
}
}
func (t *ACLListStorageBuilder) traverseFromHead(f func(rec *aclrecordproto2.ACLRecord, id string) error) (err error) {
for i := len(t.records) - 1; i >= 0; i-- {
err = f(t.records[i], t.rawRecords[i].Id)
if err != nil {
return err
}
}
return nil
func (t *ACLListStorageBuilder) traverseFromHead(f func(rec *aclrecordproto.ACLRecord, id string) error) (err error) {
panic("this was removed, add if needed")
}
func (t *ACLListStorageBuilder) parseRoot(root *Root) {
rawSignKey, _ := t.keychain.SigningKeysByYAMLIdentity[root.Identity].GetPublic().Raw()
rawEncKey, _ := t.keychain.EncryptionKeysByYAMLIdentity[root.Identity].GetPublic().Raw()
readKey, _ := aclrecordproto2.ACLReadKeyDerive(rawSignKey, rawEncKey)
hasher := fnv.New64()
hasher.Write(readKey.Bytes())
t.root = &aclrecordproto2.ACLRoot{
func (t *ACLListStorageBuilder) parseRoot(root *Root) (rawRoot *aclrecordproto.RawACLRecordWithId) {
rawSignKey, _ := t.keychain.SigningKeysByYAMLName[root.Identity].GetPublic().Raw()
rawEncKey, _ := t.keychain.EncryptionKeysByYAMLName[root.Identity].GetPublic().Raw()
readKey := t.keychain.ReadKeysByYAMLName[root.Identity]
aclRoot := &aclrecordproto.ACLRoot{
Identity: rawSignKey,
EncryptionKey: rawEncKey,
SpaceId: root.SpaceId,
EncryptedReadKey: nil,
DerivationScheme: "scheme",
CurrentReadKeyHash: hasher.Sum64(),
CurrentReadKeyHash: readKey.Hash,
}
t.rawRoot = t.createRaw(t.root, rawSignKey)
t.id = t.rawRoot.Id
return t.createRaw(aclRoot, rawSignKey)
}

0
common/pkg/acl/testutils/acllistbuilder/liststoragebuildergraph.go → common/commonspace/object/acl/testutils/acllistbuilder/liststoragebuildergraph.go
View file

2
common/pkg/acl/testutils/acllistbuilder/liststoragebuildergraph_nix.go → common/commonspace/object/acl/testutils/acllistbuilder/liststoragebuildergraph_nix.go
View file

@ -9,7 +9,7 @@ package acllistbuilder
import (
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/gogo/protobuf/proto"
"strings"
"unicode"

0
common/pkg/acl/testutils/acllistbuilder/ymlentities.go → common/commonspace/object/acl/testutils/acllistbuilder/ymlentities.go
View file

0
common/pkg/acl/testutils/yamltests/path.go → common/commonspace/object/acl/testutils/yamltests/path.go
View file

0
common/pkg/acl/testutils/yamltests/userjoinexample.yml → common/commonspace/object/acl/testutils/yamltests/userjoinexample.yml
View file

0
common/pkg/acl/testutils/yamltests/userremoveexample.yml → common/commonspace/object/acl/testutils/yamltests/userremoveexample.yml
View file

28
common/commonspace/object/keychain/keychain.go Normal file
View file

@ -0,0 +1,28 @@
package keychain
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
)
type Keychain struct {
keys map[string]signingkey.PubKey
}
func NewKeychain() *Keychain {
return &Keychain{
keys: make(map[string]signingkey.PubKey),
}
}
func (k *Keychain) GetOrAdd(identity string) (signingkey.PubKey, error) {
if key, exists := k.keys[identity]; exists {
return key, nil
}
res, err := signingkey.NewSigningEd25519PubKeyFromBytes([]byte(identity))
if err != nil {
return nil, err
}
k.keys[identity] = res.(signingkey.PubKey)
return res.(signingkey.PubKey), nil
}

14
common/commonspace/object/syncobjectgetter/syncobjectgetter.go Normal file
View file

@ -0,0 +1,14 @@
package syncobjectgetter
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync/synchandler"
)
type SyncObject interface {
synchandler.SyncHandler
}
type SyncObjectGetter interface {
GetObject(ctx context.Context, objectId string) (SyncObject, error)
}

4
common/pkg/acl/tree/change.go → common/commonspace/object/tree/objecttree/change.go
View file

@ -1,8 +1,8 @@
package tree
package objecttree
import (
"errors"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
)
var (

18
common/pkg/acl/tree/changebuilder.go → common/commonspace/object/tree/objecttree/changebuilder.go
View file

@ -1,10 +1,10 @@
package tree
package objecttree
import (
"errors"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cid"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/cidutil"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
"github.com/gogo/protobuf/proto"
@ -45,10 +45,10 @@ type ChangeBuilder interface {
type changeBuilder struct {
rootChange *treechangeproto.RawTreeChangeWithId
keys *common.Keychain
keys *keychain.Keychain
}
func NewChangeBuilder(keys *common.Keychain, rootChange *treechangeproto.RawTreeChangeWithId) ChangeBuilder {
func NewChangeBuilder(keys *keychain.Keychain, rootChange *treechangeproto.RawTreeChangeWithId) ChangeBuilder {
return &changeBuilder{keys: keys, rootChange: rootChange}
}
@ -60,7 +60,7 @@ func (c *changeBuilder) ConvertFromRaw(rawIdChange *treechangeproto.RawTreeChang
if verify {
// verifying ID
if !cid.VerifyCID(rawIdChange.RawChange, rawIdChange.Id) {
if !cidutil.VerifyCID(rawIdChange.RawChange, rawIdChange.Id) {
err = ErrIncorrectCID
return
}
@ -131,7 +131,7 @@ func (c *changeBuilder) BuildInitialContent(payload InitialContent) (ch *Change,
return
}
id, err := cid.NewCIDFromBytes(marshalledRawChange)
id, err := cidutil.NewCIDFromBytes(marshalledRawChange)
if err != nil {
return
}
@ -186,7 +186,7 @@ func (c *changeBuilder) BuildContent(payload BuilderContent) (ch *Change, rawIdC
return
}
id, err := cid.NewCIDFromBytes(marshalledRawChange)
id, err := cidutil.NewCIDFromBytes(marshalledRawChange)
if err != nil {
return
}

6
common/pkg/acl/tree/changevalidator.go → common/commonspace/object/tree/objecttree/changevalidator.go
View file

@ -1,9 +1,9 @@
package tree
package objecttree
import (
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
)
type ObjectTreeValidator interface {

2
common/pkg/acl/tree/descriptionparser.go → common/commonspace/object/tree/objecttree/descriptionparser.go
View file

@ -1,4 +1,4 @@
package tree
package objecttree
type DescriptionParser interface {
ParseChange(*Change) ([]string, error)

32
common/pkg/acl/tree/mock_objecttree/mock_objecttree.go → common/commonspace/object/tree/objecttree/mock_objecttree/mock_objecttree.go
View file

@ -1,16 +1,16 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree (interfaces: ObjectTree)
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree (interfaces: ObjectTree)
// Package mock_tree is a generated GoMock package.
package mock_tree
// Package mock_objecttree is a generated GoMock package.
package mock_objecttree
import (
context "context"
reflect "reflect"
storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
tree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
treechangeproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
objecttree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
treechangeproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
treestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
gomock "github.com/golang/mock/gomock"
)
@ -38,10 +38,10 @@ func (m *MockObjectTree) EXPECT() *MockObjectTreeMockRecorder {
}
// AddContent mocks base method.
func (m *MockObjectTree) AddContent(arg0 context.Context, arg1 tree.SignableChangeContent) (tree.AddResult, error) {
func (m *MockObjectTree) AddContent(arg0 context.Context, arg1 objecttree.SignableChangeContent) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddContent", arg0, arg1)
ret0, _ := ret[0].(tree.AddResult)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -53,10 +53,10 @@ func (mr *MockObjectTreeMockRecorder) AddContent(arg0, arg1 interface{}) *gomock
}
// AddRawChanges mocks base method.
func (m *MockObjectTree) AddRawChanges(arg0 context.Context, arg1 tree.RawChangesPayload) (tree.AddResult, error) {
func (m *MockObjectTree) AddRawChanges(arg0 context.Context, arg1 objecttree.RawChangesPayload) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChanges", arg0, arg1)
ret0, _ := ret[0].(tree.AddResult)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -186,7 +186,7 @@ func (mr *MockObjectTreeMockRecorder) ID() *gomock.Call {
}
// Iterate mocks base method.
func (m *MockObjectTree) Iterate(arg0 func([]byte) (interface{}, error), arg1 func(*tree.Change) bool) error {
func (m *MockObjectTree) Iterate(arg0 func([]byte) (interface{}, error), arg1 func(*objecttree.Change) bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Iterate", arg0, arg1)
ret0, _ := ret[0].(error)
@ -200,7 +200,7 @@ func (mr *MockObjectTreeMockRecorder) Iterate(arg0, arg1 interface{}) *gomock.Ca
}
// IterateFrom mocks base method.
func (m *MockObjectTree) IterateFrom(arg0 string, arg1 func([]byte) (interface{}, error), arg2 func(*tree.Change) bool) error {
func (m *MockObjectTree) IterateFrom(arg0 string, arg1 func([]byte) (interface{}, error), arg2 func(*objecttree.Change) bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IterateFrom", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
@ -250,10 +250,10 @@ func (mr *MockObjectTreeMockRecorder) RUnlock() *gomock.Call {
}
// Root mocks base method.
func (m *MockObjectTree) Root() *tree.Change {
func (m *MockObjectTree) Root() *objecttree.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Root")
ret0, _ := ret[0].(*tree.Change)
ret0, _ := ret[0].(*objecttree.Change)
return ret0
}
@ -278,10 +278,10 @@ func (mr *MockObjectTreeMockRecorder) SnapshotPath() *gomock.Call {
}
// Storage mocks base method.
func (m *MockObjectTree) Storage() storage.TreeStorage {
func (m *MockObjectTree) Storage() treestorage.TreeStorage {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Storage")
ret0, _ := ret[0].(storage.TreeStorage)
ret0, _ := ret[0].(treestorage.TreeStorage)
return ret0
}

36
common/pkg/acl/tree/objecttree.go → common/commonspace/object/tree/objecttree/objecttree.go
View file

@ -1,14 +1,14 @@
//go:generate mockgen -destination mock_objecttree/mock_objecttree.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree ObjectTree
package tree
//go:generate mockgen -destination mock_objecttree/mock_objecttree.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree ObjectTree
package objecttree
import (
"context"
"errors"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/aclrecordproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
list "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/aclrecordproto"
list2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
"sync"
@ -59,7 +59,7 @@ type ObjectTree interface {
SnapshotPath() []string
ChangesAfterCommonSnapshot(snapshotPath, heads []string) ([]*treechangeproto.RawTreeChangeWithId, error)
Storage() storage.TreeStorage
Storage() treestorage.TreeStorage
AddContent(ctx context.Context, content SignableChangeContent) (AddResult, error)
AddRawChanges(ctx context.Context, changes RawChangesPayload) (AddResult, error)
@ -69,12 +69,12 @@ type ObjectTree interface {
}
type objectTree struct {
treeStorage storage.TreeStorage
treeStorage treestorage.TreeStorage
changeBuilder ChangeBuilder
validator ObjectTreeValidator
rawChangeLoader *rawChangeLoader
treeBuilder *treeBuilder
aclList list.ACLList
aclList list2.ACLList
id string
root *treechangeproto.RawTreeChangeWithId
@ -96,18 +96,18 @@ type objectTree struct {
type objectTreeDeps struct {
changeBuilder ChangeBuilder
treeBuilder *treeBuilder
treeStorage storage.TreeStorage
treeStorage treestorage.TreeStorage
validator ObjectTreeValidator
rawChangeLoader *rawChangeLoader
aclList list.ACLList
aclList list2.ACLList
}
func defaultObjectTreeDeps(
rootChange *treechangeproto.RawTreeChangeWithId,
treeStorage storage.TreeStorage,
aclList list.ACLList) objectTreeDeps {
treeStorage treestorage.TreeStorage,
aclList list2.ACLList) objectTreeDeps {
keychain := common.NewKeychain()
keychain := keychain.NewKeychain()
changeBuilder := NewChangeBuilder(keychain, rootChange)
treeBuilder := newTreeBuilder(treeStorage, changeBuilder)
return objectTreeDeps{
@ -145,7 +145,7 @@ func (ot *objectTree) Header() *treechangeproto.RawTreeChangeWithId {
return ot.root
}
func (ot *objectTree) Storage() storage.TreeStorage {
func (ot *objectTree) Storage() treestorage.TreeStorage {
return ot.treeStorage
}
@ -202,7 +202,7 @@ func (ot *objectTree) prepareBuilderContent(content SignableChangeContent) (cnt
canWrite := state.HasPermission(content.Identity, aclrecordproto.ACLUserPermissions_Writer) ||
state.HasPermission(content.Identity, aclrecordproto.ACLUserPermissions_Admin)
if !canWrite {
err = list.ErrInsufficientPermissions
err = list2.ErrInsufficientPermissions
return
}
@ -469,7 +469,7 @@ func (ot *objectTree) IterateFrom(id string, convert ChangeConvertFunc, iterate
}
readKey, exists := ot.keys[c.ReadKeyHash]
if !exists {
err = list.ErrNoReadKey
err = list2.ErrNoReadKey
return
}

16
common/pkg/acl/tree/objecttree_test.go → common/commonspace/object/tree/objecttree/objecttree_test.go
View file

@ -1,11 +1,11 @@
package tree
package objecttree
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/acllistbuilder"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/testutils/acllistbuilder"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"testing"
@ -53,9 +53,9 @@ func (c *mockChangeCreator) createRaw(id, aclId, snapshotId string, isSnapshot b
}
}
func (c *mockChangeCreator) createNewTreeStorage(treeId, aclHeadId string) storage.TreeStorage {
func (c *mockChangeCreator) createNewTreeStorage(treeId, aclHeadId string) treestorage.TreeStorage {
root := c.createRoot(treeId, aclHeadId)
treeStorage, _ := storage.NewInMemoryTreeStorage(root, []string{root.Id}, []*treechangeproto.RawTreeChangeWithId{root})
treeStorage, _ := treestorage.NewInMemoryTreeStorage(root, []string{root.Id}, []*treechangeproto.RawTreeChangeWithId{root})
return treeStorage
}
@ -95,7 +95,7 @@ func (m *mockChangeValidator) ValidateFullTree(tree *Tree, aclList list.ACLList)
type testTreeContext struct {
aclList list.ACLList
treeStorage storage.TreeStorage
treeStorage treestorage.TreeStorage
changeBuilder *mockChangeBuilder
changeCreator *mockChangeCreator
objTree ObjectTree

24
common/pkg/acl/tree/objecttreefactory.go → common/commonspace/object/tree/objecttree/objecttreefactory.go
View file

@ -1,10 +1,10 @@
package tree
package objecttree
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/common"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
storage2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/keychain"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/symmetric"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
@ -21,7 +21,7 @@ type ObjectTreeCreatePayload struct {
IsEncrypted bool
}
func BuildObjectTree(treeStorage storage2.TreeStorage, aclList list.ACLList) (ObjectTree, error) {
func BuildObjectTree(treeStorage treestorage.TreeStorage, aclList list.ACLList) (ObjectTree, error) {
rootChange, err := treeStorage.Root()
if err != nil {
return nil, err
@ -33,14 +33,14 @@ func BuildObjectTree(treeStorage storage2.TreeStorage, aclList list.ACLList) (Ob
func CreateDerivedObjectTree(
payload ObjectTreeCreatePayload,
aclList list.ACLList,
createStorage storage2.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
createStorage treestorage.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
return createObjectTree(payload, 0, nil, aclList, createStorage)
}
func CreateObjectTree(
payload ObjectTreeCreatePayload,
aclList list.ACLList,
createStorage storage2.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
createStorage treestorage.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
bytes := make([]byte, 32)
_, err = rand.Read(bytes)
if err != nil {
@ -54,7 +54,7 @@ func createObjectTree(
timestamp int64,
seed []byte,
aclList list.ACLList,
createStorage storage2.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
createStorage treestorage.TreeStorageCreatorFunc) (objTree ObjectTree, err error) {
aclList.RLock()
aclHeadId := aclList.Head().Id
aclList.RUnlock()
@ -72,14 +72,13 @@ func createObjectTree(
Seed: seed,
}
_, raw, err := NewChangeBuilder(common.NewKeychain(), nil).BuildInitialContent(cnt)
_, raw, err := NewChangeBuilder(keychain.NewKeychain(), nil).BuildInitialContent(cnt)
if err != nil {
return
}
// create storage
st, err := createStorage(storage2.TreeStorageCreatePayload{
TreeId: raw.Id,
st, err := createStorage(treestorage.TreeStorageCreatePayload{
RootRawChange: raw,
Changes: []*treechangeproto.RawTreeChangeWithId{raw},
Heads: []string{raw.Id},
@ -130,6 +129,7 @@ func buildObjectTree(deps objectTreeDeps) (ObjectTree, error) {
objTree.id = objTree.treeStorage.Id()
objTree.id = objTree.treeStorage.Id()
objTree.root, err = objTree.treeStorage.Root()
if err != nil {
return nil, err

10
common/pkg/acl/tree/rawloader.go → common/commonspace/object/tree/objecttree/rawloader.go
View file

@ -1,15 +1,15 @@
package tree
package objecttree
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
"time"
)
type rawChangeLoader struct {
treeStorage storage.TreeStorage
treeStorage treestorage.TreeStorage
changeBuilder ChangeBuilder
// buffers
@ -23,7 +23,7 @@ type rawCacheEntry struct {
position int
}
func newRawChangeLoader(treeStorage storage.TreeStorage, changeBuilder ChangeBuilder) *rawChangeLoader {
func newRawChangeLoader(treeStorage treestorage.TreeStorage, changeBuilder ChangeBuilder) *rawChangeLoader {
return &rawChangeLoader{
treeStorage: treeStorage,
changeBuilder: changeBuilder,

17
common/commonspace/object/tree/objecttree/rawtreevalidator.go Normal file
View file

@ -0,0 +1,17 @@
package objecttree
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
)
func ValidateRawTree(payload treestorage.TreeStorageCreatePayload, aclList list.ACLList) (err error) {
provider := treestorage.NewInMemoryTreeStorageProvider()
treeStorage, err := provider.CreateTreeStorage(payload)
if err != nil {
return
}
_, err = BuildObjectTree(treeStorage, aclList)
return
}

2
common/pkg/acl/tree/signablecontent.go → common/commonspace/object/tree/objecttree/signablecontent.go
View file

@ -1,4 +1,4 @@
package tree
package objecttree
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/keys/asymmetric/signingkey"

2
common/pkg/acl/tree/tree.go → common/commonspace/object/tree/objecttree/tree.go
View file

@ -1,4 +1,4 @@
package tree
package objecttree
import (
"bytes"

2
common/pkg/acl/tree/tree_test.go → common/commonspace/object/tree/objecttree/tree_test.go
View file

@ -1,4 +1,4 @@
package tree
package objecttree
import (
"fmt"

8
common/pkg/acl/tree/treebuilder.go → common/commonspace/object/tree/objecttree/treebuilder.go
View file

@ -1,11 +1,11 @@
package tree
package objecttree
import (
"context"
"errors"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
"go.uber.org/zap"
"time"
@ -17,7 +17,7 @@ var (
)
type treeBuilder struct {
treeStorage storage.TreeStorage
treeStorage treestorage.TreeStorage
builder ChangeBuilder
cache map[string]*Change
@ -28,7 +28,7 @@ type treeBuilder struct {
loadBuffer []*Change
}
func newTreeBuilder(storage storage.TreeStorage, builder ChangeBuilder) *treeBuilder {
func newTreeBuilder(storage treestorage.TreeStorage, builder ChangeBuilder) *treeBuilder {
return &treeBuilder{
treeStorage: storage,
builder: builder,

2
common/pkg/acl/tree/treegraph.go → common/commonspace/object/tree/objecttree/treegraph.go
View file

@ -2,7 +2,7 @@
// +build !linux,!darwin android ios nographviz
// +build !amd64
package tree
package objecttree
import "fmt"

45
common/pkg/acl/tree/treegraph_nix.go → common/commonspace/object/tree/objecttree/treegraph_nix.go
View file

@ -5,20 +5,18 @@
// +build !nographviz
// +build amd64 arm64
package acltree
package objecttree
import (
"bytes"
"fmt"
"strings"
"time"
"unicode"
"github.com/goccy/go-graphviz"
"github.com/goccy/go-graphviz/cgraph"
"strings"
"time"
)
func (t *Tree) Graph() (data string, err error) {
func (t *Tree) Graph(parser DescriptionParser) (data string, err error) {
var order = make(map[string]string)
var seq = 0
t.Iterate(t.RootId(), func(c *Change) (isContinue bool) {
@ -46,44 +44,15 @@ func (t *Tree) Graph() (data string, err error) {
if e != nil {
return e
}
if c.Content.GetAclData() != nil {
n.SetStyle(cgraph.FilledNodeStyle)
} else if c.IsSnapshot {
n.SetStyle(cgraph.DashedNodeStyle)
}
nodes[c.Id] = n
ord := order[c.Id]
if ord == "" {
ord = "miss"
}
var chSymbs []string
if c.Content.AclData != nil {
for _, chc := range c.Content.AclData.AclContent {
tp := fmt.Sprintf("%T", chc.Value)
tp = strings.Replace(tp, "ACLChange_ACLContent_Value_", "", 1)
res := ""
for _, ts := range tp {
if unicode.IsUpper(ts) {
res += string(ts)
}
}
chSymbs = append(chSymbs, res)
}
}
if c.DecryptedDocumentChange != nil {
// TODO: add some parser to provide custom unmarshalling for the document change
//for _, chc := range c.DecryptedDocumentChange.Content {
// tp := fmt.Sprintf("%T", chc.Value)
// tp = strings.Replace(tp, "ChangeContent_Value_", "", 1)
// res := ""
// for _, ts := range tp {
// if unicode.IsUpper(ts) {
// res += string(ts)
// }
// }
// chSymbs = append(chSymbs, res)
//}
chSymbs = append(chSymbs, "DEC")
chSymbs, err := parser.ParseChange(c)
if err != nil {
return err
}
shortId := c.Id

2
common/pkg/acl/tree/treeiterator.go → common/commonspace/object/tree/objecttree/treeiterator.go
View file

@ -1,4 +1,4 @@
package tree
package objecttree
import (
"sync"

2
common/pkg/acl/tree/treereduce.go → common/commonspace/object/tree/objecttree/treereduce.go
View file

@ -1,4 +1,4 @@
package tree
package objecttree
import "math"

2
common/pkg/acl/tree/util.go → common/commonspace/object/tree/objecttree/util.go
View file

@ -1,4 +1,4 @@
package tree
package objecttree
func commonSnapshotForTwoPaths(ourPath []string, theirPath []string) (string, error) {
var i int

34
common/commonspace/synctree/mock_synctree/mock_synctree.go → common/commonspace/object/tree/synctree/mock_synctree/mock_synctree.go
View file

@ -1,5 +1,5 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree (interfaces: SyncClient,SyncTree,ReceiveQueue,HeadNotifiable)
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree (interfaces: SyncClient,SyncTree,ReceiveQueue,HeadNotifiable)
// Package mock_synctree is a generated GoMock package.
package mock_synctree
@ -8,10 +8,10 @@ import (
context "context"
reflect "reflect"
objecttree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
treechangeproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
treestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
spacesyncproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
storage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
tree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
treechangeproto "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
gomock "github.com/golang/mock/gomock"
)
@ -67,7 +67,7 @@ func (mr *MockSyncClientMockRecorder) BroadcastAsyncOrSendResponsible(arg0 inter
}
// CreateFullSyncRequest mocks base method.
func (m *MockSyncClient) CreateFullSyncRequest(arg0 tree.ObjectTree, arg1, arg2 []string) (*treechangeproto.TreeSyncMessage, error) {
func (m *MockSyncClient) CreateFullSyncRequest(arg0 objecttree.ObjectTree, arg1, arg2 []string) (*treechangeproto.TreeSyncMessage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateFullSyncRequest", arg0, arg1, arg2)
ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage)
@ -82,7 +82,7 @@ func (mr *MockSyncClientMockRecorder) CreateFullSyncRequest(arg0, arg1, arg2 int
}
// CreateFullSyncResponse mocks base method.
func (m *MockSyncClient) CreateFullSyncResponse(arg0 tree.ObjectTree, arg1, arg2 []string) (*treechangeproto.TreeSyncMessage, error) {
func (m *MockSyncClient) CreateFullSyncResponse(arg0 objecttree.ObjectTree, arg1, arg2 []string) (*treechangeproto.TreeSyncMessage, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateFullSyncResponse", arg0, arg1, arg2)
ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage)
@ -97,7 +97,7 @@ func (mr *MockSyncClientMockRecorder) CreateFullSyncResponse(arg0, arg1, arg2 in
}
// CreateHeadUpdate mocks base method.
func (m *MockSyncClient) CreateHeadUpdate(arg0 tree.ObjectTree, arg1 []*treechangeproto.RawTreeChangeWithId) *treechangeproto.TreeSyncMessage {
func (m *MockSyncClient) CreateHeadUpdate(arg0 objecttree.ObjectTree, arg1 []*treechangeproto.RawTreeChangeWithId) *treechangeproto.TreeSyncMessage {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateHeadUpdate", arg0, arg1)
ret0, _ := ret[0].(*treechangeproto.TreeSyncMessage)
@ -162,10 +162,10 @@ func (m *MockSyncTree) EXPECT() *MockSyncTreeMockRecorder {
}
// AddContent mocks base method.
func (m *MockSyncTree) AddContent(arg0 context.Context, arg1 tree.SignableChangeContent) (tree.AddResult, error) {
func (m *MockSyncTree) AddContent(arg0 context.Context, arg1 objecttree.SignableChangeContent) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddContent", arg0, arg1)
ret0, _ := ret[0].(tree.AddResult)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -177,10 +177,10 @@ func (mr *MockSyncTreeMockRecorder) AddContent(arg0, arg1 interface{}) *gomock.C
}
// AddRawChanges mocks base method.
func (m *MockSyncTree) AddRawChanges(arg0 context.Context, arg1 tree.RawChangesPayload) (tree.AddResult, error) {
func (m *MockSyncTree) AddRawChanges(arg0 context.Context, arg1 objecttree.RawChangesPayload) (objecttree.AddResult, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "AddRawChanges", arg0, arg1)
ret0, _ := ret[0].(tree.AddResult)
ret0, _ := ret[0].(objecttree.AddResult)
ret1, _ := ret[1].(error)
return ret0, ret1
}
@ -324,7 +324,7 @@ func (mr *MockSyncTreeMockRecorder) ID() *gomock.Call {
}
// Iterate mocks base method.
func (m *MockSyncTree) Iterate(arg0 func([]byte) (interface{}, error), arg1 func(*tree.Change) bool) error {
func (m *MockSyncTree) Iterate(arg0 func([]byte) (interface{}, error), arg1 func(*objecttree.Change) bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Iterate", arg0, arg1)
ret0, _ := ret[0].(error)
@ -338,7 +338,7 @@ func (mr *MockSyncTreeMockRecorder) Iterate(arg0, arg1 interface{}) *gomock.Call
}
// IterateFrom mocks base method.
func (m *MockSyncTree) IterateFrom(arg0 string, arg1 func([]byte) (interface{}, error), arg2 func(*tree.Change) bool) error {
func (m *MockSyncTree) IterateFrom(arg0 string, arg1 func([]byte) (interface{}, error), arg2 func(*objecttree.Change) bool) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "IterateFrom", arg0, arg1, arg2)
ret0, _ := ret[0].(error)
@ -402,10 +402,10 @@ func (mr *MockSyncTreeMockRecorder) RUnlock() *gomock.Call {
}
// Root mocks base method.
func (m *MockSyncTree) Root() *tree.Change {
func (m *MockSyncTree) Root() *objecttree.Change {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Root")
ret0, _ := ret[0].(*tree.Change)
ret0, _ := ret[0].(*objecttree.Change)
return ret0
}
@ -430,10 +430,10 @@ func (mr *MockSyncTreeMockRecorder) SnapshotPath() *gomock.Call {
}
// Storage mocks base method.
func (m *MockSyncTree) Storage() storage.TreeStorage {
func (m *MockSyncTree) Storage() treestorage.TreeStorage {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Storage")
ret0, _ := ret[0].(storage.TreeStorage)
ret0, _ := ret[0].(treestorage.TreeStorage)
return ret0
}

8
common/commonspace/synctree/queuedclient.go → common/commonspace/object/tree/synctree/queuedclient.go
View file

@ -1,16 +1,16 @@
package synctree
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync"
)
type queuedClient struct {
SyncClient
queue syncservice.ActionQueue
queue objectsync.ActionQueue
}
func newQueuedClient(client SyncClient, queue syncservice.ActionQueue) SyncClient {
func newQueuedClient(client SyncClient, queue objectsync.ActionQueue) SyncClient {
return &queuedClient{
SyncClient: client,
queue: queue,

2
common/commonspace/synctree/receivequeue.go → common/commonspace/object/tree/synctree/receivequeue.go
View file

@ -2,7 +2,7 @@ package synctree
import (
"errors"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"sync"
)

16
common/commonspace/synctree/requestfactory.go → common/commonspace/object/tree/synctree/requestfactory.go
View file

@ -2,16 +2,16 @@ package synctree
import (
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
)
type RequestFactory interface {
CreateHeadUpdate(t tree.ObjectTree, added []*treechangeproto.RawTreeChangeWithId) (msg *treechangeproto.TreeSyncMessage)
CreateHeadUpdate(t objecttree.ObjectTree, added []*treechangeproto.RawTreeChangeWithId) (msg *treechangeproto.TreeSyncMessage)
CreateNewTreeRequest() (msg *treechangeproto.TreeSyncMessage)
CreateFullSyncRequest(t tree.ObjectTree, theirHeads, theirSnapshotPath []string) (req *treechangeproto.TreeSyncMessage, err error)
CreateFullSyncResponse(t tree.ObjectTree, theirHeads, theirSnapshotPath []string) (*treechangeproto.TreeSyncMessage, error)
CreateFullSyncRequest(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (req *treechangeproto.TreeSyncMessage, err error)
CreateFullSyncResponse(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (*treechangeproto.TreeSyncMessage, error)
}
var sharedFactory = &requestFactory{}
@ -22,7 +22,7 @@ func GetRequestFactory() RequestFactory {
type requestFactory struct{}
func (r *requestFactory) CreateHeadUpdate(t tree.ObjectTree, added []*treechangeproto.RawTreeChangeWithId) (msg *treechangeproto.TreeSyncMessage) {
func (r *requestFactory) CreateHeadUpdate(t objecttree.ObjectTree, added []*treechangeproto.RawTreeChangeWithId) (msg *treechangeproto.TreeSyncMessage) {
return treechangeproto.WrapHeadUpdate(&treechangeproto.TreeHeadUpdate{
Heads: t.Heads(),
Changes: added,
@ -34,7 +34,7 @@ func (r *requestFactory) CreateNewTreeRequest() (msg *treechangeproto.TreeSyncMe
return treechangeproto.WrapFullRequest(&treechangeproto.TreeFullSyncRequest{}, nil)
}
func (r *requestFactory) CreateFullSyncRequest(t tree.ObjectTree, theirHeads, theirSnapshotPath []string) (msg *treechangeproto.TreeSyncMessage, err error) {
func (r *requestFactory) CreateFullSyncRequest(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (msg *treechangeproto.TreeSyncMessage, err error) {
req := &treechangeproto.TreeFullSyncRequest{}
if t == nil {
return nil, fmt.Errorf("tree should not be empty")
@ -54,7 +54,7 @@ func (r *requestFactory) CreateFullSyncRequest(t tree.ObjectTree, theirHeads, th
return
}
func (r *requestFactory) CreateFullSyncResponse(t tree.ObjectTree, theirHeads, theirSnapshotPath []string) (msg *treechangeproto.TreeSyncMessage, err error) {
func (r *requestFactory) CreateFullSyncResponse(t objecttree.ObjectTree, theirHeads, theirSnapshotPath []string) (msg *treechangeproto.TreeSyncMessage, err error) {
resp := &treechangeproto.TreeFullSyncResponse{
Heads: t.Heads(),
SnapshotPath: t.SnapshotPath(),

14
common/commonspace/synctree/syncclient.go → common/commonspace/object/tree/synctree/syncclient.go
View file

@ -1,11 +1,11 @@
//go:generate mockgen -destination mock_synctree/mock_synctree.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree SyncClient,SyncTree,ReceiveQueue,HeadNotifiable
//go:generate mockgen -destination mock_synctree/mock_synctree.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree SyncClient,SyncTree,ReceiveQueue,HeadNotifiable
package synctree
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
)
type SyncClient interface {
@ -16,21 +16,21 @@ type SyncClient interface {
}
type syncClient struct {
syncservice.StreamPool
objectsync.StreamPool
RequestFactory
spaceId string
connector nodeconf.ConfConnector
configuration nodeconf.Configuration
checker syncservice.StreamChecker
checker objectsync.StreamChecker
}
func newSyncClient(
spaceId string,
pool syncservice.StreamPool,
pool objectsync.StreamPool,
factory RequestFactory,
configuration nodeconf.Configuration,
checker syncservice.StreamChecker) SyncClient {
checker objectsync.StreamChecker) SyncClient {
return &syncClient{
StreamPool: pool,
RequestFactory: factory,

72
common/commonspace/synctree/synctree.go → common/commonspace/object/tree/synctree/synctree.go
View file

@ -5,17 +5,17 @@ import (
"errors"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice/synchandler"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync/synchandler"
spacestorage "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/net/peer"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/gogo/protobuf/proto"
"go.uber.org/zap"
"sync/atomic"
@ -31,14 +31,14 @@ type HeadNotifiable interface {
}
type SyncTree interface {
tree.ObjectTree
objecttree.ObjectTree
synchandler.SyncHandler
Ping() (err error)
}
// SyncTree sends head updates to sync service and also sends new changes to update listener
type syncTree struct {
tree.ObjectTree
objecttree.ObjectTree
synchandler.SyncHandler
syncClient SyncClient
syncStatus syncstatus.SyncStatusUpdater
@ -51,16 +51,16 @@ type syncTree struct {
var log = logger.NewNamed("commonspace.synctree").Sugar()
var createDerivedObjectTree = tree.CreateDerivedObjectTree
var createObjectTree = tree.CreateObjectTree
var buildObjectTree = tree.BuildObjectTree
var createDerivedObjectTree = objecttree.CreateDerivedObjectTree
var createObjectTree = objecttree.CreateObjectTree
var buildObjectTree = objecttree.BuildObjectTree
var createSyncClient = newWrappedSyncClient
type CreateDeps struct {
SpaceId string
Payload tree.ObjectTreeCreatePayload
Payload objecttree.ObjectTreeCreatePayload
Configuration nodeconf.Configuration
SyncService syncservice.SyncService
ObjectSync objectsync.ObjectSync
AclList list.ACLList
SpaceStorage spacestorage.SpaceStorage
SyncStatus syncstatus.SyncStatusUpdater
@ -69,13 +69,13 @@ type CreateDeps struct {
type BuildDeps struct {
SpaceId string
SyncService syncservice.SyncService
ObjectSync objectsync.ObjectSync
Configuration nodeconf.Configuration
HeadNotifiable HeadNotifiable
Listener updatelistener.UpdateListener
AclList list.ACLList
SpaceStorage spacestorage.SpaceStorage
TreeStorage storage.TreeStorage
TreeStorage treestorage.TreeStorage
TreeUsage *atomic.Int32
SyncStatus syncstatus.SyncStatusUpdater
}
@ -83,10 +83,10 @@ type BuildDeps struct {
func newWrappedSyncClient(
spaceId string,
factory RequestFactory,
syncService syncservice.SyncService,
objectSync objectsync.ObjectSync,
configuration nodeconf.Configuration) SyncClient {
syncClient := newSyncClient(spaceId, syncService.StreamPool(), factory, configuration, syncService.StreamChecker())
return newQueuedClient(syncClient, syncService.ActionQueue())
syncClient := newSyncClient(spaceId, objectSync.StreamPool(), factory, configuration, objectSync.StreamChecker())
return newQueuedClient(syncClient, objectSync.ActionQueue())
}
func DeriveSyncTree(ctx context.Context, deps CreateDeps) (id string, err error) {
@ -98,7 +98,7 @@ func DeriveSyncTree(ctx context.Context, deps CreateDeps) (id string, err error)
syncClient := createSyncClient(
deps.SpaceId,
sharedFactory,
deps.SyncService,
deps.ObjectSync,
deps.Configuration)
id = objTree.ID()
@ -119,7 +119,7 @@ func CreateSyncTree(ctx context.Context, deps CreateDeps) (id string, err error)
syncClient := createSyncClient(
deps.SpaceId,
sharedFactory,
deps.SyncService,
deps.ObjectSync,
deps.Configuration)
id = objTree.ID()
@ -145,12 +145,12 @@ func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t
return
}
err = deps.SyncService.StreamChecker().CheckPeerConnection(peerId)
err = deps.ObjectSync.StreamChecker().CheckPeerConnection(peerId)
if err != nil {
return
}
resp, err := deps.SyncService.StreamPool().SendSync(peerId, objMsg)
resp, err := deps.ObjectSync.StreamPool().SendSync(peerId, objMsg)
if err != nil {
return
}
@ -165,7 +165,7 @@ func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t
return buildSyncTree(ctx, false, deps)
}
if err != nil && err != storage.ErrUnknownTreeId {
if err != nil && err != treestorage.ErrUnknownTreeId {
return
}
@ -188,7 +188,7 @@ func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t
}
fullSyncResp := resp.GetContent().GetFullSyncResponse()
payload := storage.TreeStorageCreatePayload{
payload := treestorage.TreeStorageCreatePayload{
RootRawChange: resp.RootChange,
Changes: fullSyncResp.Changes,
Heads: fullSyncResp.Heads,
@ -196,7 +196,7 @@ func BuildSyncTreeOrGetRemote(ctx context.Context, id string, deps BuildDeps) (t
// basically building tree with in-memory storage and validating that it was without errors
log.With(zap.String("id", id)).Debug("validating tree")
err = tree.ValidateRawTree(payload, deps.AclList)
err = objecttree.ValidateRawTree(payload, deps.AclList)
if err != nil {
return
}
@ -216,7 +216,7 @@ func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t Sy
syncClient := createSyncClient(
deps.SpaceId,
sharedFactory,
deps.SyncService,
deps.ObjectSync,
deps.Configuration)
syncTree := &syncTree{
ObjectTree: objTree,
@ -241,21 +241,21 @@ func buildSyncTree(ctx context.Context, isFirstBuild bool, deps BuildDeps) (t Sy
return
}
func (s *syncTree) IterateFrom(id string, convert tree.ChangeConvertFunc, iterate tree.ChangeIterateFunc) (err error) {
func (s *syncTree) IterateFrom(id string, convert objecttree.ChangeConvertFunc, iterate objecttree.ChangeIterateFunc) (err error) {
if err = s.checkAlive(); err != nil {
return
}
return s.ObjectTree.IterateFrom(id, convert, iterate)
}
func (s *syncTree) Iterate(convert tree.ChangeConvertFunc, iterate tree.ChangeIterateFunc) (err error) {
func (s *syncTree) Iterate(convert objecttree.ChangeConvertFunc, iterate objecttree.ChangeIterateFunc) (err error) {
if err = s.checkAlive(); err != nil {
return
}
return s.ObjectTree.Iterate(convert, iterate)
}
func (s *syncTree) AddContent(ctx context.Context, content tree.SignableChangeContent) (res tree.AddResult, err error) {
func (s *syncTree) AddContent(ctx context.Context, content objecttree.SignableChangeContent) (res objecttree.AddResult, err error) {
if err = s.checkAlive(); err != nil {
return
}
@ -272,7 +272,7 @@ func (s *syncTree) AddContent(ctx context.Context, content tree.SignableChangeCo
return
}
func (s *syncTree) AddRawChanges(ctx context.Context, changesPayload tree.RawChangesPayload) (res tree.AddResult, err error) {
func (s *syncTree) AddRawChanges(ctx context.Context, changesPayload objecttree.RawChangesPayload) (res objecttree.AddResult, err error) {
if err = s.checkAlive(); err != nil {
return
}
@ -282,15 +282,15 @@ func (s *syncTree) AddRawChanges(ctx context.Context, changesPayload tree.RawCha
}
if s.listener != nil {
switch res.Mode {
case tree.Nothing:
case objecttree.Nothing:
return
case tree.Append:
case objecttree.Append:
s.listener.Update(s)
case tree.Rebuild:
case objecttree.Rebuild:
s.listener.Rebuild(s)
}
}
if res.Mode != tree.Nothing {
if res.Mode != objecttree.Nothing {
if s.notifiable != nil {
s.notifiable.UpdateHeads(s.ID(), res.Heads)
}

70
common/commonspace/synctree/synctree_test.go → common/commonspace/object/tree/synctree/synctree_test.go
View file

@ -2,26 +2,26 @@ package synctree
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/storage/mock_storage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/acl/list/mock_list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree/mock_objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/mock_synctree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener/mock_updatelistener"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacestorage/mock_spacestorage"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/mock_synctree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener/mock_updatelistener"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/nodeconf"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/list/mock_list"
storage2 "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/storage"
tree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree/mock_objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"testing"
)
type syncTreeMatcher struct {
objTree tree.ObjectTree
objTree objecttree.ObjectTree
client SyncClient
listener updatelistener.UpdateListener
}
@ -38,8 +38,8 @@ func (s syncTreeMatcher) String() string {
return ""
}
func syncClientFuncCreator(client SyncClient) func(spaceId string, factory RequestFactory, syncService syncservice.SyncService, configuration nodeconf.Configuration) SyncClient {
return func(spaceId string, factory RequestFactory, syncService syncservice.SyncService, configuration nodeconf.Configuration) SyncClient {
func syncClientFuncCreator(client SyncClient) func(spaceId string, factory RequestFactory, objectSync objectsync.ObjectSync, configuration nodeconf.Configuration) SyncClient {
return func(spaceId string, factory RequestFactory, objectSync objectsync.ObjectSync, configuration nodeconf.Configuration) SyncClient {
return client
}
}
@ -51,12 +51,12 @@ func Test_DeriveSyncTree(t *testing.T) {
syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
aclListMock := mock_list.NewMockACLList(ctrl)
objTreeMock := newTestObjMock(mock_tree.NewMockObjectTree(ctrl))
spaceStorageMock := mock_storage.NewMockSpaceStorage(ctrl)
objTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
spaceStorageMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
headNotifiableMock := mock_synctree.NewMockHeadNotifiable(ctrl)
spaceId := "spaceId"
expectedPayload := tree.ObjectTreeCreatePayload{SpaceId: spaceId}
createDerivedObjectTree = func(payload tree.ObjectTreeCreatePayload, l list.ACLList, create storage2.TreeStorageCreatorFunc) (objTree tree.ObjectTree, err error) {
expectedPayload := objecttree.ObjectTreeCreatePayload{SpaceId: spaceId}
createDerivedObjectTree = func(payload objecttree.ObjectTreeCreatePayload, l list.ACLList, create treestorage.TreeStorageCreatorFunc) (objTree objecttree.ObjectTree, err error) {
require.Equal(t, l, aclListMock)
require.Equal(t, expectedPayload, payload)
return objTreeMock, nil
@ -88,12 +88,12 @@ func Test_CreateSyncTree(t *testing.T) {
syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
aclListMock := mock_list.NewMockACLList(ctrl)
objTreeMock := newTestObjMock(mock_tree.NewMockObjectTree(ctrl))
spaceStorageMock := mock_storage.NewMockSpaceStorage(ctrl)
objTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
spaceStorageMock := mock_spacestorage.NewMockSpaceStorage(ctrl)
headNotifiableMock := mock_synctree.NewMockHeadNotifiable(ctrl)
spaceId := "spaceId"
expectedPayload := tree.ObjectTreeCreatePayload{SpaceId: spaceId}
createObjectTree = func(payload tree.ObjectTreeCreatePayload, l list.ACLList, create storage2.TreeStorageCreatorFunc) (objTree tree.ObjectTree, err error) {
expectedPayload := objecttree.ObjectTreeCreatePayload{SpaceId: spaceId}
createObjectTree = func(payload objecttree.ObjectTreeCreatePayload, l list.ACLList, create treestorage.TreeStorageCreatorFunc) (objTree objecttree.ObjectTree, err error) {
require.Equal(t, l, aclListMock)
require.Equal(t, expectedPayload, payload)
return objTreeMock, nil
@ -126,7 +126,7 @@ func Test_BuildSyncTree(t *testing.T) {
updateListenerMock := mock_updatelistener.NewMockUpdateListener(ctrl)
syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
objTreeMock := newTestObjMock(mock_tree.NewMockObjectTree(ctrl))
objTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
tr := &syncTree{
ObjectTree: objTreeMock,
SyncHandler: nil,
@ -139,13 +139,13 @@ func Test_BuildSyncTree(t *testing.T) {
headUpdate := &treechangeproto.TreeSyncMessage{}
t.Run("AddRawChanges update", func(t *testing.T) {
changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
payload := tree.RawChangesPayload{
payload := objecttree.RawChangesPayload{
NewHeads: nil,
RawChanges: changes,
}
expectedRes := tree.AddResult{
expectedRes := objecttree.AddResult{
Added: changes,
Mode: tree.Append,
Mode: objecttree.Append,
}
objTreeMock.EXPECT().AddRawChanges(gomock.Any(), gomock.Eq(payload)).
Return(expectedRes, nil)
@ -160,14 +160,14 @@ func Test_BuildSyncTree(t *testing.T) {
t.Run("AddRawChanges rebuild", func(t *testing.T) {
changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
payload := tree.RawChangesPayload{
payload := objecttree.RawChangesPayload{
NewHeads: nil,
RawChanges: changes,
}
expectedRes := tree.AddResult{
expectedRes := objecttree.AddResult{
Added: changes,
Mode: tree.Rebuild,
Mode: objecttree.Rebuild,
}
objTreeMock.EXPECT().AddRawChanges(gomock.Any(), gomock.Eq(payload)).
Return(expectedRes, nil)
@ -182,13 +182,13 @@ func Test_BuildSyncTree(t *testing.T) {
t.Run("AddRawChanges nothing", func(t *testing.T) {
changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
payload := tree.RawChangesPayload{
payload := objecttree.RawChangesPayload{
NewHeads: nil,
RawChanges: changes,
}
expectedRes := tree.AddResult{
expectedRes := objecttree.AddResult{
Added: changes,
Mode: tree.Nothing,
Mode: objecttree.Nothing,
}
objTreeMock.EXPECT().AddRawChanges(gomock.Any(), gomock.Eq(payload)).
Return(expectedRes, nil)
@ -200,11 +200,11 @@ func Test_BuildSyncTree(t *testing.T) {
t.Run("AddContent", func(t *testing.T) {
changes := []*treechangeproto.RawTreeChangeWithId{{Id: "some"}}
content := tree.SignableChangeContent{
content := objecttree.SignableChangeContent{
Data: []byte("abcde"),
}
expectedRes := tree.AddResult{
Mode: tree.Append,
expectedRes := objecttree.AddResult{
Mode: objecttree.Append,
Added: changes,
}
objTreeMock.EXPECT().ID().Return("id").AnyTimes()

18
common/commonspace/synctree/synctreehandler.go → common/commonspace/object/tree/synctree/synctreehandler.go
View file

@ -2,11 +2,11 @@ package synctree
import (
"context"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/objectsync/synchandler"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/spacesyncproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncservice/synchandler"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/util/slice"
"github.com/gogo/protobuf/proto"
"go.uber.org/zap"
@ -14,7 +14,7 @@ import (
)
type syncTreeHandler struct {
objTree tree.ObjectTree
objTree objecttree.ObjectTree
syncClient SyncClient
syncStatus syncstatus.SyncStatusUpdater
handlerLock sync.Mutex
@ -23,7 +23,7 @@ type syncTreeHandler struct {
const maxQueueSize = 5
func newSyncTreeHandler(objTree tree.ObjectTree, syncClient SyncClient, syncStatus syncstatus.SyncStatusUpdater) synchandler.SyncHandler {
func newSyncTreeHandler(objTree objecttree.ObjectTree, syncClient SyncClient, syncStatus syncstatus.SyncStatusUpdater) synchandler.SyncHandler {
return &syncTreeHandler{
objTree: objTree,
syncClient: syncClient,
@ -118,7 +118,7 @@ func (s *syncTreeHandler) handleHeadUpdate(
return
}
_, err = objTree.AddRawChanges(ctx, tree.RawChangesPayload{
_, err = objTree.AddRawChanges(ctx, objecttree.RawChangesPayload{
NewHeads: update.Heads,
RawChanges: update.Changes,
})
@ -167,7 +167,7 @@ func (s *syncTreeHandler) handleFullSyncRequest(
}()
if len(request.Changes) != 0 && !s.alreadyHasHeads(objTree, request.Heads) {
_, err = objTree.AddRawChanges(ctx, tree.RawChangesPayload{
_, err = objTree.AddRawChanges(ctx, objecttree.RawChangesPayload{
NewHeads: request.Heads,
RawChanges: request.Changes,
})
@ -207,13 +207,13 @@ func (s *syncTreeHandler) handleFullSyncResponse(
return
}
_, err = objTree.AddRawChanges(ctx, tree.RawChangesPayload{
_, err = objTree.AddRawChanges(ctx, objecttree.RawChangesPayload{
NewHeads: response.Heads,
RawChanges: response.Changes,
})
return
}
func (s *syncTreeHandler) alreadyHasHeads(t tree.ObjectTree, heads []string) bool {
func (s *syncTreeHandler) alreadyHasHeads(t objecttree.ObjectTree, heads []string) bool {
return slice.UnsortedEquals(t.Heads(), heads) || t.HasChanges(heads...)
}

34
common/commonspace/synctree/synctreehandler_test.go → common/commonspace/object/tree/synctree/synctreehandler_test.go
View file

@ -3,11 +3,11 @@ package synctree
import (
"context"
"fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree/mock_objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/mock_synctree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/treechangeproto"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/syncstatus"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/mock_synctree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree/mock_objecttree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/treechangeproto"
"github.com/golang/mock/gomock"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
@ -16,11 +16,11 @@ import (
)
type testObjTreeMock struct {
*mock_tree.MockObjectTree
*mock_objecttree.MockObjectTree
m sync.Mutex
}
func newTestObjMock(mockTree *mock_tree.MockObjectTree) *testObjTreeMock {
func newTestObjMock(mockTree *mock_objecttree.MockObjectTree) *testObjTreeMock {
return &testObjTreeMock{
MockObjectTree: mockTree,
}
@ -46,7 +46,7 @@ type syncHandlerFixture struct {
func newSyncHandlerFixture(t *testing.T) *syncHandlerFixture {
ctrl := gomock.NewController(t)
syncClientMock := mock_synctree.NewMockSyncClient(ctrl)
objectTreeMock := newTestObjMock(mock_tree.NewMockObjectTree(ctrl))
objectTreeMock := newTestObjMock(mock_objecttree.NewMockObjectTree(ctrl))
receiveQueueMock := mock_synctree.NewMockReceiveQueue(ctrl)
syncHandler := &syncTreeHandler{
@ -93,11 +93,11 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).Times(2)
fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(false)
fx.objectTreeMock.EXPECT().
AddRawChanges(gomock.Any(), gomock.Eq(tree.RawChangesPayload{
AddRawChanges(gomock.Any(), gomock.Eq(objecttree.RawChangesPayload{
NewHeads: []string{"h1"},
RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
})).
Return(tree.AddResult{}, nil)
Return(objecttree.AddResult{}, nil)
fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2", "h1"})
fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(true)
@ -127,11 +127,11 @@ func TestSyncHandler_HandleHeadUpdate(t *testing.T) {
fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).AnyTimes()
fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(false)
fx.objectTreeMock.EXPECT().
AddRawChanges(gomock.Any(), gomock.Eq(tree.RawChangesPayload{
AddRawChanges(gomock.Any(), gomock.Eq(objecttree.RawChangesPayload{
NewHeads: []string{"h1"},
RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
})).
Return(tree.AddResult{}, nil)
Return(objecttree.AddResult{}, nil)
fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(false)
fx.syncClientMock.EXPECT().
CreateFullSyncRequest(gomock.Eq(fx.objectTreeMock), gomock.Eq([]string{"h1"}), gomock.Eq([]string{"h1"})).
@ -247,11 +247,11 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
fx.objectTreeMock.EXPECT().Heads().Return([]string{"h2"}).AnyTimes()
fx.objectTreeMock.EXPECT().HasChanges(gomock.Eq([]string{"h1"})).Return(false)
fx.objectTreeMock.EXPECT().
AddRawChanges(gomock.Any(), gomock.Eq(tree.RawChangesPayload{
AddRawChanges(gomock.Any(), gomock.Eq(objecttree.RawChangesPayload{
NewHeads: []string{"h1"},
RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
})).
Return(tree.AddResult{}, nil)
Return(objecttree.AddResult{}, nil)
fx.syncClientMock.EXPECT().
CreateFullSyncResponse(gomock.Eq(fx.objectTreeMock), gomock.Eq([]string{"h1"}), gomock.Eq([]string{"h1"})).
Return(fullResponse, nil)
@ -351,11 +351,11 @@ func TestSyncHandler_HandleFullSyncRequest(t *testing.T) {
HasChanges(gomock.Eq([]string{"h1"})).
Return(false)
fx.objectTreeMock.EXPECT().
AddRawChanges(gomock.Any(), gomock.Eq(tree.RawChangesPayload{
AddRawChanges(gomock.Any(), gomock.Eq(objecttree.RawChangesPayload{
NewHeads: []string{"h1"},
RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
})).
Return(tree.AddResult{}, fmt.Errorf(""))
Return(objecttree.AddResult{}, fmt.Errorf(""))
fx.syncClientMock.EXPECT().SendAsync(gomock.Eq(senderId), gomock.Any(), gomock.Eq(""))
fx.receiveQueueMock.EXPECT().ClearQueue(senderId)
@ -393,11 +393,11 @@ func TestSyncHandler_HandleFullSyncResponse(t *testing.T) {
HasChanges(gomock.Eq([]string{"h1"})).
Return(false)
fx.objectTreeMock.EXPECT().
AddRawChanges(gomock.Any(), gomock.Eq(tree.RawChangesPayload{
AddRawChanges(gomock.Any(), gomock.Eq(objecttree.RawChangesPayload{
NewHeads: []string{"h1"},
RawChanges: []*treechangeproto.RawTreeChangeWithId{chWithId},
})).
Return(tree.AddResult{}, nil)
Return(objecttree.AddResult{}, nil)
fx.receiveQueueMock.EXPECT().ClearQueue(senderId)
err := fx.syncHandler.HandleMessage(ctx, senderId, objectMsg)

8
common/commonspace/synctree/updatelistener/mock_updatelistener/mock_updatelistener.go → common/commonspace/object/tree/synctree/updatelistener/mock_updatelistener/mock_updatelistener.go
View file

@ -1,5 +1,5 @@
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener (interfaces: UpdateListener)
// Source: github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener (interfaces: UpdateListener)
// Package mock_updatelistener is a generated GoMock package.
package mock_updatelistener
@ -7,7 +7,7 @@ package mock_updatelistener
import (
reflect "reflect"
tree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
objecttree "github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
gomock "github.com/golang/mock/gomock"
)
@ -35,7 +35,7 @@ func (m *MockUpdateListener) EXPECT() *MockUpdateListenerMockRecorder {
}
// Rebuild mocks base method.
func (m *MockUpdateListener) Rebuild(arg0 tree.ObjectTree) {
func (m *MockUpdateListener) Rebuild(arg0 objecttree.ObjectTree) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Rebuild", arg0)
}
@ -47,7 +47,7 @@ func (mr *MockUpdateListenerMockRecorder) Rebuild(arg0 interface{}) *gomock.Call
}
// Update mocks base method.
func (m *MockUpdateListener) Update(arg0 tree.ObjectTree) {
func (m *MockUpdateListener) Update(arg0 objecttree.ObjectTree) {
m.ctrl.T.Helper()
m.ctrl.Call(m, "Update", arg0)
}

8
common/commonspace/synctree/updatelistener/updatelistener.go → common/commonspace/object/tree/synctree/updatelistener/updatelistener.go
View file

@ -1,11 +1,11 @@
//go:generate mockgen -destination mock_updatelistener/mock_updatelistener.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener UpdateListener
//go:generate mockgen -destination mock_updatelistener/mock_updatelistener.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/synctree/updatelistener UpdateListener
package updatelistener
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/object/tree/objecttree"
)
type UpdateListener interface {
Update(tree tree.ObjectTree)
Rebuild(tree tree.ObjectTree)
Update(tree objecttree.ObjectTree)
Rebuild(tree objecttree.ObjectTree)
}

0
common/pkg/acl/treechangeproto/protos/treechange.proto → common/commonspace/object/tree/treechangeproto/protos/treechange.proto
View file

0
common/pkg/acl/treechangeproto/treechange.go → common/commonspace/object/tree/treechangeproto/treechange.go
View file

0
common/pkg/acl/treechangeproto/treechange.pb.go → common/commonspace/object/tree/treechangeproto/treechange.pb.go
View file

2
common/pkg/acl/storage/helpers.go → common/commonspace/object/tree/treestorage/helpers.go
View file

@ -1,4 +1,4 @@
package storage
package treestorage
import (
"bytes"

Some files were not shown because too many files have changed in this diff Show more