From 35db541479443429670dca0d95012a5f1b8cc1f3 Mon Sep 17 00:00:00 2001 From: Sergey Date: Fri, 13 Oct 2023 11:49:41 +0500 Subject: [PATCH] GO-2166: Fix space creation --- core/block/import/objectcreator.go | 3 +-- space/create.go | 2 +- space/keyconverter.go | 34 ----------------------- space/load.go | 6 ++--- space/loadingspace.go | 28 ++++++++++--------- space/objectprovider/objectprovider.go | 25 ++++++++++------- space/service.go | 8 +++--- space/space.go | 34 +++++++++++++++-------- space/space_marketplace.go | 37 ++++++++++++++++++-------- space/space_personal.go | 4 +-- 10 files changed, 90 insertions(+), 91 deletions(-) delete mode 100644 space/keyconverter.go diff --git a/core/block/import/objectcreator.go b/core/block/import/objectcreator.go index 78ce19888..45843acbf 100644 --- a/core/block/import/objectcreator.go +++ b/core/block/import/objectcreator.go @@ -16,7 +16,6 @@ import ( "github.com/anyproto/anytype-heart/core/block/editor/smartblock" "github.com/anyproto/anytype-heart/core/block/editor/state" "github.com/anyproto/anytype-heart/core/block/editor/template" - "github.com/anyproto/anytype-heart/core/block/getblock" "github.com/anyproto/anytype-heart/core/block/history" "github.com/anyproto/anytype-heart/core/block/import/converter" "github.com/anyproto/anytype-heart/core/block/import/syncer" @@ -207,7 +206,7 @@ func (oc *ObjectCreator) createNewObject( if err == nil { respDetails = sb.Details() } else if errors.Is(err, treestorage.ErrTreeExists) { - err = getblock.Do(oc.service, newID, func(sb smartblock.SmartBlock) error { + err = spc.Do(newID, func(sb smartblock.SmartBlock) error { respDetails = sb.Details() return nil }) diff --git a/space/create.go b/space/create.go index 51c006c71..1262ec7a7 100644 --- a/space/create.go +++ b/space/create.go @@ -12,7 +12,7 @@ func (s *service) create(ctx context.Context, coreSpace *spacecore.AnySpace) (Sp } // load - if err := s.startLoad(ctx, coreSpace.Id()); err != nil { + if err := s.startLoad(ctx, coreSpace.Id(), true); err != nil { return nil, err } return s.waitLoad(ctx, coreSpace.Id()) diff --git a/space/keyconverter.go b/space/keyconverter.go deleted file mode 100644 index 571ad9f58..000000000 --- a/space/keyconverter.go +++ /dev/null @@ -1,34 +0,0 @@ -package space - -import ( - "context" - - "github.com/anyproto/anytype-heart/core/domain" - "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock" - "github.com/anyproto/anytype-heart/pkg/lib/localstore/addr" -) - -func (s *space) GetRelationIdByKey(ctx context.Context, key domain.RelationKey) (id string, err error) { - uk, err := domain.NewUniqueKey(smartblock.SmartBlockTypeRelation, key.String()) - if err != nil { - return "", err - } - - if s.Id() == addr.AnytypeMarketplaceWorkspace { - return addr.BundledRelationURLPrefix + key.String(), nil - } - return s.DeriveObjectID(ctx, uk) -} - -func (s *space) GetTypeIdByKey(ctx context.Context, key domain.TypeKey) (id string, err error) { - uk, err := domain.NewUniqueKey(smartblock.SmartBlockTypeObjectType, key.String()) - if err != nil { - return "", err - } - - if s.Id() == addr.AnytypeMarketplaceWorkspace { - return addr.BundledObjectTypeURLPrefix + key.String(), nil - } - - return s.DeriveObjectID(ctx, uk) -} diff --git a/space/load.go b/space/load.go index b95eaed2b..b916c4d0d 100644 --- a/space/load.go +++ b/space/load.go @@ -9,12 +9,12 @@ import ( "github.com/anyproto/anytype-heart/space/spaceinfo" ) -func (s *service) startLoad(ctx context.Context, spaceID string) (err error) { +func (s *service) startLoad(ctx context.Context, spaceID string, justCreated bool) (err error) { s.mu.Lock() defer s.mu.Unlock() status := s.getStatus(spaceID) - + // Do nothing if space is already loading if status.LocalStatus != spaceinfo.LocalStatusUnknown { return nil } @@ -34,7 +34,7 @@ func (s *service) startLoad(ctx context.Context, spaceID string) (err error) { if err = s.setStatus(ctx, info); err != nil { return } - s.loading[spaceID] = newLoadingSpace(s.ctx, spaceID, s) + s.loading[spaceID] = s.newLoadingSpace(s.ctx, spaceID, justCreated) return } diff --git a/space/loadingspace.go b/space/loadingspace.go index e6db0c48c..3d88349b4 100644 --- a/space/loadingspace.go +++ b/space/loadingspace.go @@ -12,24 +12,14 @@ import ( var loadingRetryTimeout = time.Second * 20 type spaceServiceProvider interface { - open(ctx context.Context, spaceId string) (Space, error) + open(ctx context.Context, spaceId string, justCreated bool) (Space, error) onLoad(spaceId string, sp Space, loadErr error) (err error) } -func newLoadingSpace(ctx context.Context, spaceID string, serviceProvider spaceServiceProvider) *loadingSpace { - ls := &loadingSpace{ - ID: spaceID, - retryTimeout: loadingRetryTimeout, - spaceServiceProvider: serviceProvider, - loadCh: make(chan struct{}), - } - go ls.loadRetry(ctx) - return ls -} - type loadingSpace struct { ID string retryTimeout time.Duration + justCreated bool // indicates that user created space spaceServiceProvider spaceServiceProvider @@ -39,6 +29,18 @@ type loadingSpace struct { loadCh chan struct{} } +func (s *service) newLoadingSpace(ctx context.Context, spaceID string, justCreated bool) *loadingSpace { + ls := &loadingSpace{ + ID: spaceID, + retryTimeout: loadingRetryTimeout, + justCreated: justCreated, + spaceServiceProvider: s, + loadCh: make(chan struct{}), + } + go ls.loadRetry(ctx) + return ls +} + func (ls *loadingSpace) loadRetry(ctx context.Context) { defer func() { if err := ls.spaceServiceProvider.onLoad(ls.ID, ls.space, ls.loadErr); err != nil { @@ -64,7 +66,7 @@ func (ls *loadingSpace) loadRetry(ctx context.Context) { } func (ls *loadingSpace) load(ctx context.Context) (ok bool) { - sp, err := ls.spaceServiceProvider.open(ctx, ls.ID) + sp, err := ls.spaceServiceProvider.open(ctx, ls.ID, ls.justCreated) if errors.Is(err, spacesyncproto.ErrSpaceMissing) { return false } diff --git a/space/objectprovider/objectprovider.go b/space/objectprovider/objectprovider.go index 923f0bdf8..d815a3c44 100644 --- a/space/objectprovider/objectprovider.go +++ b/space/objectprovider/objectprovider.go @@ -8,12 +8,12 @@ import ( "github.com/anyproto/any-sync/app/logger" "go.uber.org/zap" - editorsb "github.com/anyproto/anytype-heart/core/block/editor/smartblock" + "github.com/anyproto/anytype-heart/core/block/editor/smartblock" "github.com/anyproto/anytype-heart/core/block/editor/state" "github.com/anyproto/anytype-heart/core/block/object/objectcache" "github.com/anyproto/anytype-heart/core/domain" "github.com/anyproto/anytype-heart/pkg/lib/bundle" - "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock" + coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock" "github.com/anyproto/anytype-heart/pkg/lib/threads" ) @@ -22,7 +22,7 @@ var log = logger.NewNamed("client.spaceobject.objectprovider") type ObjectProvider interface { DeriveObjectIDs(ctx context.Context) (objIDs threads.DerivedSmartblockIds, err error) LoadObjects(ctx context.Context, ids []string) (err error) - CreateMandatoryObjects(ctx context.Context) (err error) + CreateMandatoryObjects(ctx context.Context, space smartblock.Space) (err error) } func NewObjectProvider(spaceId string, personalSpaceId string, cache objectcache.Cache) ObjectProvider { @@ -54,7 +54,7 @@ func (o *objectProvider) DeriveObjectIDs(ctx context.Context) (objIDs threads.De return o.derivedObjectIds, nil } - var sbTypes []smartblock.SmartBlockType + var sbTypes []coresb.SmartBlockType if o.isPersonal() { sbTypes = threads.PersonalSpaceTypes } else { @@ -77,7 +77,7 @@ func (o *objectProvider) DeriveObjectIDs(ctx context.Context) (objIDs threads.De } // deriving system types for _, ot := range bundle.SystemTypes { - uk, err := domain.NewUniqueKey(smartblock.SmartBlockTypeObjectType, ot.String()) + uk, err := domain.NewUniqueKey(coresb.SmartBlockTypeObjectType, ot.String()) if err != nil { return objIDs, err } @@ -89,7 +89,7 @@ func (o *objectProvider) DeriveObjectIDs(ctx context.Context) (objIDs threads.De } // deriving system relations for _, rk := range bundle.SystemRelations { - uk, err := domain.NewUniqueKey(smartblock.SmartBlockTypeRelation, rk.String()) + uk, err := domain.NewUniqueKey(coresb.SmartBlockTypeRelation, rk.String()) if err != nil { return objIDs, err } @@ -113,8 +113,8 @@ func (o *objectProvider) LoadObjects(ctx context.Context, objIDs []string) (err return } -func (o *objectProvider) CreateMandatoryObjects(ctx context.Context) (err error) { - var sbTypes []smartblock.SmartBlockType +func (o *objectProvider) CreateMandatoryObjects(ctx context.Context, space smartblock.Space) (err error) { + var sbTypes []coresb.SmartBlockType if o.isPersonal() { sbTypes = threads.PersonalSpaceTypes } else { @@ -128,8 +128,13 @@ func (o *objectProvider) CreateMandatoryObjects(ctx context.Context) (err error) } _, err = o.cache.DeriveTreeObject(ctx, objectcache.TreeDerivationParams{ Key: uk, - InitFunc: func(id string) *editorsb.InitContext { - return &editorsb.InitContext{Ctx: ctx, SpaceID: o.spaceId, State: state.NewDoc(id, nil).(*state.State)} + InitFunc: func(id string) *smartblock.InitContext { + return &smartblock.InitContext{ + Ctx: ctx, + SpaceID: o.spaceId, + Space: space, + State: state.NewDoc(id, nil).(*state.State), + } }, }) if err != nil { diff --git a/space/service.go b/space/service.go index 8cff66b57..c37668baa 100644 --- a/space/service.go +++ b/space/service.go @@ -126,7 +126,7 @@ func (s *service) Create(ctx context.Context) (Space, error) { } func (s *service) Get(ctx context.Context, spaceID string) (sp Space, err error) { - if err = s.startLoad(ctx, spaceID); err != nil { + if err = s.startLoad(ctx, spaceID, false); err != nil { return nil, err } return s.waitLoad(ctx, spaceID) @@ -136,12 +136,12 @@ func (s *service) GetPersonalSpace(ctx context.Context) (sp Space, err error) { return s.Get(ctx, s.personalSpaceID) } -func (s *service) open(ctx context.Context, spaceID string) (sp Space, err error) { +func (s *service) open(ctx context.Context, spaceID string, justCreated bool) (sp Space, err error) { coreSpace, err := s.spaceCore.Get(ctx, spaceID) if err != nil { return nil, err } - return s.newSpace(ctx, coreSpace) + return s.newSpace(ctx, coreSpace, justCreated) } func (s *service) IsPersonal(id string) bool { @@ -150,7 +150,7 @@ func (s *service) IsPersonal(id string) bool { func (s *service) OnViewCreated(spaceID string) { go func() { - if err := s.startLoad(s.ctx, spaceID); err != nil { + if err := s.startLoad(s.ctx, spaceID, true); err != nil { log.Warn("OnViewCreated.startLoad error", zap.Error(err)) } }() diff --git a/space/space.go b/space/space.go index d4304ca4e..1fbc36c6b 100644 --- a/space/space.go +++ b/space/space.go @@ -8,11 +8,11 @@ import ( "github.com/anyproto/any-sync/commonspace/headsync" "github.com/anyproto/any-sync/commonspace/objecttreebuilder" "github.com/anyproto/any-sync/commonspace/spacestorage" - "go.uber.org/zap" "github.com/anyproto/anytype-heart/core/block/editor/smartblock" "github.com/anyproto/anytype-heart/core/block/object/objectcache" "github.com/anyproto/anytype-heart/core/domain" + coresb "github.com/anyproto/anytype-heart/pkg/lib/core/smartblock" "github.com/anyproto/anytype-heart/pkg/lib/threads" "github.com/anyproto/anytype-heart/space/objectprovider" "github.com/anyproto/anytype-heart/space/spacecore" @@ -54,7 +54,7 @@ type space struct { loadMandatoryObjectsErr error } -func (s *service) newSpace(ctx context.Context, coreSpace *spacecore.AnySpace) (*space, error) { +func (s *service) newSpace(ctx context.Context, coreSpace *spacecore.AnySpace, justCreated bool) (*space, error) { sp := &space{ service: s, Space: coreSpace, @@ -68,16 +68,12 @@ func (s *service) newSpace(ctx context.Context, coreSpace *spacecore.AnySpace) ( if err != nil { return nil, fmt.Errorf("derive object ids: %w", err) } - - // TODO BEGIN RUN ONLY ON CREATE - // create mandatory objects - err = sp.CreateMandatoryObjects(ctx) - if err != nil { - log.Error("TEMP", zap.Error(err)) - // return nil, fmt.Errorf("CreateMandatoryObjects error: %w; spaceId: %v", err, coreSpace.Id()) + if justCreated { + err = sp.ObjectProvider.CreateMandatoryObjects(ctx, sp) + if err != nil { + return nil, fmt.Errorf("create mandatory objects: %w", err) + } } - // TODO END RUN ONLY ON CREATE - go sp.mandatoryObjectsLoad(s.ctx) return sp, nil } @@ -125,3 +121,19 @@ func (s *space) Do(objectId string, apply func(sb smartblock.SmartBlock) error) defer sb.Unlock() return apply(sb) } + +func (s *space) GetRelationIdByKey(ctx context.Context, key domain.RelationKey) (id string, err error) { + uk, err := domain.NewUniqueKey(coresb.SmartBlockTypeRelation, key.String()) + if err != nil { + return "", err + } + return s.DeriveObjectID(ctx, uk) +} + +func (s *space) GetTypeIdByKey(ctx context.Context, key domain.TypeKey) (id string, err error) { + uk, err := domain.NewUniqueKey(coresb.SmartBlockTypeObjectType, key.String()) + if err != nil { + return "", err + } + return s.DeriveObjectID(ctx, uk) +} diff --git a/space/space_marketplace.go b/space/space_marketplace.go index 2381648b5..6af3ae4d0 100644 --- a/space/space_marketplace.go +++ b/space/space_marketplace.go @@ -17,30 +17,45 @@ import ( "github.com/anyproto/any-sync/net/peer" "github.com/anyproto/anytype-heart/core/block/object/objectcache" + "github.com/anyproto/anytype-heart/core/domain" "github.com/anyproto/anytype-heart/pkg/lib/localstore/addr" ) +type marketplaceSpace struct { + *space +} + func (s *service) initMarketplaceSpace() error { - coreSpace := newMarketplace() - sp := &space{ - service: s, - Space: coreSpace, - installer: s.bundledObjectsInstaller, - loadMandatoryObjectsCh: make(chan struct{}), + coreSpace := newMarketplaceCommon() + spc := &marketplaceSpace{ + space: &space{ + service: s, + Space: coreSpace, + installer: s.bundledObjectsInstaller, + loadMandatoryObjectsCh: make(chan struct{}), + }, } - sp.Cache = objectcache.New(coreSpace, s.accountService, s.objectFactory, s.personalSpaceID, sp) + spc.Cache = objectcache.New(coreSpace, s.accountService, s.objectFactory, s.personalSpaceID, spc) - s.preLoad(sp) + s.preLoad(spc) - err := s.indexer.ReindexMarketplaceSpace(s.marketplaceSpace) + err := s.indexer.ReindexMarketplaceSpace(spc) if err != nil { return fmt.Errorf("reindex marketplace space: %w", err) } - s.marketplaceSpace = sp + s.marketplaceSpace = spc return nil } -func newMarketplace() commonspace.Space { +func (s *marketplaceSpace) GetRelationIdByKey(ctx context.Context, key domain.RelationKey) (id string, err error) { + return addr.BundledRelationURLPrefix + key.String(), nil +} + +func (s *marketplaceSpace) GetTypeIdByKey(ctx context.Context, key domain.TypeKey) (id string, err error) { + return addr.BundledObjectTypeURLPrefix + key.String(), nil +} + +func newMarketplaceCommon() commonspace.Space { return &marketplaceCommonSpace{} } diff --git a/space/space_personal.go b/space/space_personal.go index 0e273fd12..2f86e48ba 100644 --- a/space/space_personal.go +++ b/space/space_personal.go @@ -42,14 +42,14 @@ func (s *service) createPersonalSpace(ctx context.Context) (err error) { } func (s *service) loadPersonalSpace(ctx context.Context) (err error) { - err = s.startLoad(ctx, s.personalSpaceID) + err = s.startLoad(ctx, s.personalSpaceID, false) // This could happen for old accounts if errors.Is(err, ErrSpaceNotExists) { err = s.techSpace.SpaceViewCreate(ctx, s.personalSpaceID) if err != nil { return err } - err = s.startLoad(ctx, s.personalSpaceID) + err = s.startLoad(ctx, s.personalSpaceID, false) if err != nil { return err }