feat: [CDE-582]: refactor gitspaces, use spaceCache (#3227)

* feat: [CDE-582]: refactor gitspaces seperate DB layer. * feat: [CDE-582]: refactor gitspaces seperate DB layer. * feat: [CDE-582]: refactor gitspaces seperate DB layer. * feat: [CDE-582]: refactor gitspaces seperate DB layer.
harness · Jan 7, 2025 · 083a24d · 083a24d
1 parent bb5ffe1
commit 083a24d
Show file tree

Hide file tree

Showing 22 changed files with 101 additions and 127 deletions.
diff --git a/app/api/controller/gitspace/action.go b/app/api/controller/gitspace/action.go
@@ -42,7 +42,7 @@ func (c *Controller) Action(
 	if err := c.sanitizeActionInput(in); err != nil {
 		return nil, fmt.Errorf("failed to sanitize input: %w", err)
 	}
-	space, err := c.spaceStore.FindByRef(ctx, in.SpaceRef)
+	space, err := c.spaceCache.Get(ctx, in.SpaceRef)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find space: %w", err)
 	}
@@ -51,14 +51,10 @@ func (c *Controller) Action(
 		return nil, fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	gitspaceConfig, err := c.gitspaceConfigStore.FindByIdentifier(ctx, space.ID, in.Identifier)
+	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, space.Path, in.Identifier)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find gitspace config: %w", err)
 	}
-
-	gitspaceConfig.SpacePath = space.Path
-	gitspaceConfig.SpaceID = space.ID
-
 	// check if it's an internal repo
 	if gitspaceConfig.CodeRepo.Type == enum.CodeRepoTypeGitness {
 		if gitspaceConfig.CodeRepo.Ref == nil {

diff --git a/app/api/controller/gitspace/controller.go b/app/api/controller/gitspace/controller.go
@@ -27,27 +27,23 @@ import (
 )
 
 type Controller struct {
-	authorizer            authz.Authorizer
-	infraProviderSvc      *infraprovider.Service
-	gitspaceConfigStore   store.GitspaceConfigStore
-	gitspaceInstanceStore store.GitspaceInstanceStore
-	spaceStore            store.SpaceStore
-	gitspaceEventStore    store.GitspaceEventStore
-	tx                    dbtx.Transactor
-	statefulLogger        *logutil.StatefulLogger
-	scm                   *scm.SCM
-	gitspaceSvc           *gitspace.Service
-	gitspaceLimiter       limiter.Gitspace
-	repoFinder            refcache.RepoFinder
+	authorizer         authz.Authorizer
+	infraProviderSvc   *infraprovider.Service
+	spaceCache         refcache.SpaceCache
+	gitspaceEventStore store.GitspaceEventStore
+	tx                 dbtx.Transactor
+	statefulLogger     *logutil.StatefulLogger
+	scm                *scm.SCM
+	gitspaceSvc        *gitspace.Service
+	gitspaceLimiter    limiter.Gitspace
+	repoFinder         refcache.RepoFinder
 }
 
 func NewController(
 	tx dbtx.Transactor,
 	authorizer authz.Authorizer,
 	infraProviderSvc *infraprovider.Service,
-	gitspaceConfigStore store.GitspaceConfigStore,
-	gitspaceInstanceStore store.GitspaceInstanceStore,
-	spaceStore store.SpaceStore,
+	spaceCache refcache.SpaceCache,
 	gitspaceEventStore store.GitspaceEventStore,
 	statefulLogger *logutil.StatefulLogger,
 	scm *scm.SCM,
@@ -56,17 +52,15 @@ func NewController(
 	repoFinder refcache.RepoFinder,
 ) *Controller {
 	return &Controller{
-		tx:                    tx,
-		authorizer:            authorizer,
-		infraProviderSvc:      infraProviderSvc,
-		gitspaceConfigStore:   gitspaceConfigStore,
-		gitspaceInstanceStore: gitspaceInstanceStore,
-		spaceStore:            spaceStore,
-		gitspaceEventStore:    gitspaceEventStore,
-		statefulLogger:        statefulLogger,
-		scm:                   scm,
-		gitspaceSvc:           gitspaceSvc,
-		gitspaceLimiter:       gitspaceLimiter,
-		repoFinder:            repoFinder,
+		tx:                 tx,
+		authorizer:         authorizer,
+		infraProviderSvc:   infraProviderSvc,
+		spaceCache:         spaceCache,
+		gitspaceEventStore: gitspaceEventStore,
+		statefulLogger:     statefulLogger,
+		scm:                scm,
+		gitspaceSvc:        gitspaceSvc,
+		gitspaceLimiter:    gitspaceLimiter,
+		repoFinder:         repoFinder,
 	}
 }
diff --git a/app/api/controller/gitspace/create.go b/app/api/controller/gitspace/create.go
@@ -65,7 +65,7 @@ func (c *Controller) Create(
 	session *auth.Session,
 	in *CreateInput,
 ) (*types.GitspaceConfig, error) {
-	space, err := c.spaceStore.FindByRef(ctx, in.SpaceRef)
+	space, err := c.spaceCache.Get(ctx, in.SpaceRef)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find parent by ref: %w", err)
 	}
@@ -109,12 +109,12 @@ func (c *Controller) Create(
 	identifier := strings.ToLower(in.Identifier + "-" + suffixUID)
 	now := time.Now().UnixMilli()
 	var gitspaceConfig *types.GitspaceConfig
-	resourceIdentifier := in.ResourceIdentifier
 	// assume resource to be in same space if it's not explicitly specified.
 	if in.ResourceSpaceRef == "" {
 		in.ResourceSpaceRef = in.SpaceRef
 	}
-	resourceSpace, err := c.spaceStore.FindByRef(ctx, in.ResourceSpaceRef)
+	resourceIdentifier := in.ResourceIdentifier
+	resourceSpace, err := c.spaceCache.Get(ctx, in.ResourceSpaceRef)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find parent by ref: %w", err)
 	}
@@ -168,7 +168,7 @@ func (c *Controller) Create(
 			GitspaceUser:       user,
 		}
 		gitspaceConfig.InfraProviderResource = *infraProviderResource
-		err = c.gitspaceConfigStore.Create(ctx, gitspaceConfig)
+		err = c.gitspaceSvc.Create(ctx, gitspaceConfig)
 		if err != nil {
 			return fmt.Errorf("failed to create gitspace config for : %q %w", identifier, err)
 		}

diff --git a/app/api/controller/gitspace/delete.go b/app/api/controller/gitspace/delete.go
@@ -16,47 +16,32 @@ package gitspace
 
 import (
 	"context"
-	"errors"
 	"fmt"
 
 	apiauth "github.com/harness/gitness/app/api/auth"
 	"github.com/harness/gitness/app/auth"
-	"github.com/harness/gitness/store"
 	"github.com/harness/gitness/types/enum"
 
 	"github.com/rs/zerolog/log"
 )
 
-const gitspaceConfigNotFound = "Failed to find gitspace config with identifier "
-
 func (c *Controller) Delete(
 	ctx context.Context,
 	session *auth.Session,
 	spaceRef string,
 	identifier string,
 ) error {
-	space, err := c.spaceStore.FindByRef(ctx, spaceRef)
-	if err != nil {
-		return fmt.Errorf("failed to find space: %w", err)
-	}
-
-	err = apiauth.CheckGitspace(ctx, c.authorizer, session, space.Path, identifier, enum.PermissionGitspaceDelete)
+	err := apiauth.CheckGitspace(ctx, c.authorizer, session, spaceRef, identifier, enum.PermissionGitspaceDelete)
 	if err != nil {
 		return fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	gitspaceConfig, err := c.gitspaceConfigStore.FindByIdentifier(ctx, space.ID, identifier)
-	if err != nil || gitspaceConfig == nil {
-		log.Err(err).Msg(gitspaceConfigNotFound + identifier)
-		return err
-	}
-	gitspaceConfig.SpacePath = space.Path
-	instance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, gitspaceConfig.ID)
-	if err != nil && !errors.Is(err, store.ErrResourceNotFound) {
-		log.Err(err).Msgf("Failed to find latest gitspace instance for config : %s", identifier)
+	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
+	if err != nil {
+		log.Err(err).Msgf("Failed to find latest gitspace config : %s", identifier)
 		return err
 	}
-	gitspaceConfig.GitspaceInstance = instance
+	instance := gitspaceConfig.GitspaceInstance
 	if instance == nil || instance.State == enum.GitspaceInstanceStateUninitialized {
 		gitspaceConfig.IsMarkedForDeletion = true
 		gitspaceConfig.IsDeleted = true

diff --git a/app/api/controller/gitspace/events.go b/app/api/controller/gitspace/events.go
@@ -39,7 +39,7 @@ func (c *Controller) Events(
 	page int,
 	limit int,
 ) ([]*types.GitspaceEventResponse, int, error) {
-	space, err := c.spaceStore.FindByRef(ctx, spaceRef)
+	space, err := c.spaceCache.Get(ctx, spaceRef)
 	if err != nil {
 		return nil, 0, fmt.Errorf("failed to find space: %w", err)
 	}
@@ -49,15 +49,20 @@ func (c *Controller) Events(
 		return nil, 0, fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	filter := &types.GitspaceEventFilter{}
-	filter.QueryKey = identifier
-	filter.Page = page
-	filter.Size = limit
-	filter.SkipEvents = []enum.GitspaceEventType{
+	pagination := types.Pagination{
+		Page: page,
+		Size: limit,
+	}
+	skipEvents := []enum.GitspaceEventType{
 		enum.GitspaceEventTypeInfraCleanupStart,
 		enum.GitspaceEventTypeInfraCleanupCompleted,
 		enum.GitspaceEventTypeInfraCleanupFailed,
 	}
+	filter := &types.GitspaceEventFilter{
+		Pagination: pagination,
+		QueryKey:   identifier,
+		SkipEvents: skipEvents,
+	}
 	events, count, err := c.gitspaceEventStore.List(ctx, filter)
 	if err != nil {
 		return nil, 0, fmt.Errorf("failed to list gitspace events for identifier %s: %w", identifier, err)

diff --git a/app/api/controller/gitspace/find.go b/app/api/controller/gitspace/find.go
@@ -30,17 +30,12 @@ func (c *Controller) Find(
 	spaceRef string,
 	identifier string,
 ) (*types.GitspaceConfig, error) {
-	space, err := c.spaceStore.FindByRef(ctx, spaceRef)
-	if err != nil {
-		return nil, fmt.Errorf("failed to find space: %w", err)
-	}
-
-	err = apiauth.CheckGitspace(ctx, c.authorizer, session, space.Path, identifier, enum.PermissionGitspaceView)
+	err := apiauth.CheckGitspace(ctx, c.authorizer, session, spaceRef, identifier, enum.PermissionGitspaceView)
 	if err != nil {
 		return nil, fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	res, err := c.gitspaceSvc.Find(ctx, space.Path, identifier)
+	res, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find gitspace: %w", err)
 	}

diff --git a/app/api/controller/gitspace/list_all.go b/app/api/controller/gitspace/list_all.go
@@ -21,40 +21,37 @@ import (
 
 	apiauth "github.com/harness/gitness/app/api/auth"
 	"github.com/harness/gitness/app/auth"
+	"github.com/harness/gitness/store"
 	"github.com/harness/gitness/store/database/dbtx"
 	"github.com/harness/gitness/types"
 	"github.com/harness/gitness/types/enum"
 )
 
-const spaceIsDeleted = "Failed to find space: resource not found"
-
 func (c *Controller) ListAllGitspaces( // nolint:gocognit
 	ctx context.Context,
 	session *auth.Session,
 	filter *types.GitspaceFilter,
 ) ([]*types.GitspaceConfig, error) {
 	var result []*types.GitspaceConfig
 	err := c.tx.WithTx(ctx, func(ctx context.Context) (err error) {
-		allGitspaceConfigs, err := c.gitspaceConfigStore.ListWithLatestInstance(ctx, filter)
+		allGitspaceConfigs, _, _, err := c.gitspaceSvc.ListGitspacesWithInstance(ctx, *filter)
 		if err != nil {
 			return fmt.Errorf("failed to list gitspace configs: %w", err)
 		}
 
 		var spacesMap = make(map[int64]string)
-
 		for idx := 0; idx < len(allGitspaceConfigs); idx++ {
 			if spacesMap[allGitspaceConfigs[idx].SpaceID] == "" {
-				space, findSpaceErr := c.spaceStore.Find(ctx, allGitspaceConfigs[idx].SpaceID)
+				space, findSpaceErr := c.spaceCache.Get(ctx, allGitspaceConfigs[idx].SpacePath)
 				if findSpaceErr != nil {
-					if findSpaceErr.Error() != spaceIsDeleted {
+					if !errors.Is(findSpaceErr, store.ErrResourceNotFound) {
 						return fmt.Errorf(
 							"error fetching space %d: %w", allGitspaceConfigs[idx].SpaceID, findSpaceErr)
 					}
 					continue
 				}
 				spacesMap[allGitspaceConfigs[idx].SpaceID] = space.Path
 			}
-			allGitspaceConfigs[idx].SpacePath = spacesMap[allGitspaceConfigs[idx].SpaceID]
 		}
 
 		authorizedSpaceIDs, err := c.getAuthorizedSpaces(ctx, session, spacesMap)

diff --git a/app/api/controller/gitspace/logs_stream.go b/app/api/controller/gitspace/logs_stream.go
@@ -32,17 +32,12 @@ func (c *Controller) LogsStream(
 	spaceRef string,
 	identifier string,
 ) (<-chan *sse.Event, <-chan error, error) {
-	space, err := c.spaceStore.FindByRef(ctx, spaceRef)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to find space: %w", err)
-	}
-
-	err = apiauth.CheckGitspace(ctx, c.authorizer, session, space.Path, identifier, enum.PermissionGitspaceView)
+	err := apiauth.CheckGitspace(ctx, c.authorizer, session, spaceRef, identifier, enum.PermissionGitspaceView)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	gitspaceConfig, err := c.gitspaceConfigStore.FindByIdentifier(ctx, space.ID, identifier)
+	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to find gitspace config: %w", err)
 	}

diff --git a/app/api/controller/gitspace/lookup_repo.go b/app/api/controller/gitspace/lookup_repo.go
@@ -48,7 +48,7 @@ func (c *Controller) LookupRepo(
 	if err := c.sanitizeLookupRepoInput(in); err != nil {
 		return nil, fmt.Errorf("invalid input: %w", err)
 	}
-	space, err := c.spaceStore.FindByRef(ctx, in.SpaceRef)
+	space, err := c.spaceCache.Get(ctx, in.SpaceRef)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find space: %w", err)
 	}

diff --git a/app/api/controller/gitspace/update.go b/app/api/controller/gitspace/update.go
@@ -47,16 +47,12 @@ func (c *Controller) Update(
 	if err := c.sanitizeUpdateInput(in); err != nil {
 		return fmt.Errorf("failed to sanitize input: %w", err)
 	}
-	space, err := c.spaceStore.FindByRef(ctx, spaceRef)
-	if err != nil {
-		return fmt.Errorf("failed to find space: %w", err)
-	}
-	err = apiauth.CheckGitspace(ctx, c.authorizer, session, space.Path, identifier, enum.PermissionGitspaceEdit)
+	err := apiauth.CheckGitspace(ctx, c.authorizer, session, spaceRef, identifier, enum.PermissionGitspaceEdit)
 	if err != nil {
 		return fmt.Errorf("failed to authorize: %w", err)
 	}
 
-	gitspaceConfig, err := c.gitspaceConfigStore.FindByIdentifier(ctx, space.ID, identifier)
+	gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
 	if err != nil {
 		return fmt.Errorf("failed to find gitspace config: %w", err)
 	}

diff --git a/app/api/controller/gitspace/wire.go b/app/api/controller/gitspace/wire.go
@@ -37,9 +37,7 @@ func ProvideController(
 	tx dbtx.Transactor,
 	authorizer authz.Authorizer,
 	infraProviderSvc *infraprovider.Service,
-	configStore store.GitspaceConfigStore,
-	instanceStore store.GitspaceInstanceStore,
-	spaceStore store.SpaceStore,
+	spaceCache refcache.SpaceCache,
 	eventStore store.GitspaceEventStore,
 	statefulLogger *logutil.StatefulLogger,
 	scm *scm.SCM,
@@ -51,9 +49,7 @@ func ProvideController(
 		tx,
 		authorizer,
 		infraProviderSvc,
-		configStore,
-		instanceStore,
-		spaceStore,
+		spaceCache,
 		eventStore,
 		statefulLogger,
 		scm,

diff --git a/app/api/controller/infraprovider/controller.go b/app/api/controller/infraprovider/controller.go
@@ -17,23 +17,23 @@ package infraprovider
 import (
 	"github.com/harness/gitness/app/auth/authz"
 	"github.com/harness/gitness/app/services/infraprovider"
-	"github.com/harness/gitness/app/store"
+	"github.com/harness/gitness/app/services/refcache"
 )
 
 type Controller struct {
 	authorizer       authz.Authorizer
-	spaceStore       store.SpaceStore
+	spaceCache       refcache.SpaceCache
 	infraproviderSvc *infraprovider.Service
 }
 
 func NewController(
 	authorizer authz.Authorizer,
-	spaceStore store.SpaceStore,
+	spaceCache refcache.SpaceCache,
 	infraproviderSvc *infraprovider.Service,
 ) *Controller {
 	return &Controller{
 		authorizer:       authorizer,
-		spaceStore:       spaceStore,
+		spaceCache:       spaceCache,
 		infraproviderSvc: infraproviderSvc,
 	}
 }
diff --git a/app/api/controller/infraprovider/create.go b/app/api/controller/infraprovider/create.go
@@ -66,7 +66,7 @@ func (c *Controller) Create(
 	if err := c.sanitizeCreateInput(in); err != nil {
 		return nil, fmt.Errorf("invalid input: %w", err)
 	}
-	parentSpace, err := c.spaceStore.FindByRef(ctx, in.SpaceRef)
+	parentSpace, err := c.spaceCache.Get(ctx, in.SpaceRef)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find parent by ref %q : %w", in.SpaceRef, err)
 	}