USEFULL
/
drone
mirror of https://github.com/harness/drone.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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.
BT-10437
Ansuman Satapathy 2025-01-07 05:06:39 +00:00 committed by Harness
parent bb5ffe1cae
commit 083a24d8eb
22 changed files with 101 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
app/api/controller/gitspace/action.go
View File

@ -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 {

48
app/api/controller/gitspace/controller.go
View File

@ -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,
}
}

8
app/api/controller/gitspace/create.go
View File

@ -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)
}

25
app/api/controller/gitspace/delete.go
View File

@ -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)
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.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)
return err
}
gitspaceConfig.GitspaceInstance = instance
instance := gitspaceConfig.GitspaceInstance
if instance == nil || instance.State == enum.GitspaceInstanceStateUninitialized {
gitspaceConfig.IsMarkedForDeletion = true
gitspaceConfig.IsDeleted = true

17
app/api/controller/gitspace/events.go
View File

@ -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)

9
app/api/controller/gitspace/find.go
View File

@ -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)
}

11
app/api/controller/gitspace/list_all.go
View File

@ -21,13 +21,12 @@ 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,
@ -35,18 +34,17 @@ func (c *Controller) ListAllGitspaces( // nolint:gocognit
) ([]*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)
}
@ -54,7 +52,6 @@ func (c *Controller) ListAllGitspaces( // nolint:gocognit
}
spacesMap[allGitspaceConfigs[idx].SpaceID] = space.Path
}
allGitspaceConfigs[idx].SpacePath = spacesMap[allGitspaceConfigs[idx].SpaceID]
}
authorizedSpaceIDs, err := c.getAuthorizedSpaces(ctx, session, spacesMap)

9
app/api/controller/gitspace/logs_stream.go
View File

@ -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)
}

2
app/api/controller/gitspace/lookup_repo.go
View File

@ -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)
}

8
app/api/controller/gitspace/update.go
View File

@ -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)
}

8
app/api/controller/gitspace/wire.go
View File

@ -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,

8
app/api/controller/infraprovider/controller.go
View File

@ -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,
}
}

2
app/api/controller/infraprovider/create.go
View File

@ -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)
}

4
app/api/controller/infraprovider/create_resources.go
View File

@ -35,7 +35,7 @@ func (c *Controller) CreateTemplate(
spaceRef string,
) (*types.InfraProviderTemplate, error) {
now := time.Now().UnixMilli()
parentSpace, err := c.spaceStore.FindByRef(ctx, spaceRef)
parentSpace, err := c.spaceCache.Get(ctx, spaceRef)
if err != nil {
return nil, fmt.Errorf("failed to find parent by ref: %w", err)
}
@ -83,7 +83,7 @@ func (c *Controller) CreateResources(
return nil, fmt.Errorf("invalid input: %w", err)
}
now := time.Now().UnixMilli()
parentSpace, err := c.spaceStore.FindByRef(ctx, spaceRef)
parentSpace, err := c.spaceCache.Get(ctx, spaceRef)
if err != nil {
return nil, fmt.Errorf("failed to find parent by ref: %w", err)
}

2
app/api/controller/infraprovider/find.go
View File

@ -30,7 +30,7 @@ func (c *Controller) Find(
spaceRef string,
identifier string,
) (*types.InfraProviderConfig, error) {
space, err := c.spaceStore.FindByRef(ctx, spaceRef)
space, err := c.spaceCache.Get(ctx, spaceRef)
if err != nil {
return nil, fmt.Errorf("failed to find space: %w", err)
}

6
app/api/controller/infraprovider/wire.go
View File

@ -17,7 +17,7 @@ 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"
"github.com/google/wire"
)
@ -29,8 +29,8 @@ var WireSet = wire.NewSet(
func ProvideController(
authorizer authz.Authorizer,
spaceStore store.SpaceStore,
spaceCache refcache.SpaceCache,
infraproviderSvc *infraprovider.Service,
) *Controller {
return NewController(authorizer, spaceStore, infraproviderSvc)
return NewController(authorizer, spaceCache, infraproviderSvc)
}

2
app/api/controller/space/list_gitspaces.go
View File

@ -47,5 +47,5 @@ func (c *Controller) ListGitspaces(
filter.Deleted = &deleted
filter.MarkedForDeletion = &markedForDeletion
return c.gitspaceSvc.ListGitspacesForSpace(ctx, space, filter)
return c.gitspaceSvc.ListGitspacesWithInstance(ctx, filter)
}

7
app/api/handler/gitspace/list_all_gitspaces.go
View File

@ -36,6 +36,13 @@ func HandleListAllGitspaces(gitspaceCtrl *gitspace.Controller) http.HandlerFunc
MarkedForDeletion: &markedForDeletion,
}
filter.Owner = enum.GitspaceOwnerSelf
maxListing := types.Pagination{
Page: 0,
Size: 10000,
}
filter.QueryFilter = types.ListQueryFilter{
Pagination: maxListing,
}
gitspaces, err := gitspaceCtrl.ListAllGitspaces(ctx, session, filter)
if err != nil {
render.TranslatedUserError(ctx, w, err)

6
app/services/gitspace/find.go
View File

@ -26,7 +26,7 @@ import (
"github.com/harness/gitness/types/enum"
)
func (c *Service) Find(
func (c *Service) FindWithLatestInstance(
ctx context.Context,
spaceRef string,
identifier string,
@ -78,7 +78,7 @@ func (c *Service) setInstance(
return nil
}
func (c *Service) FindByID(
func (c *Service) FindWithLatestInstanceByID(
ctx context.Context,
id int64,
includeDeleted bool,
@ -114,7 +114,7 @@ func (c *Service) FindAll(
return fmt.Errorf("failed to find gitspace config: %w", err)
}
for _, gitspaceConfig := range gitspaceConfigs {
// FindByRef method is backed by cache as opposed to Find()
// FindByRef method is backed by cache as opposed to Find
space, err := c.spaceStore.FindByRef(ctx, strconv.FormatInt(gitspaceConfig.SpaceID, 10))
if err != nil {
return fmt.Errorf("failed to find space: %w", err)

32
app/services/gitspace/gitspace.go
View File

@ -17,6 +17,7 @@ package gitspace
import (
"context"
"fmt"
"strconv"
gitspaceevents "github.com/harness/gitness/app/events/gitspace"
"github.com/harness/gitness/app/gitspace/orchestrator"
@ -68,13 +69,12 @@ type Service struct {
config *types.Config
}
func (c *Service) ListGitspacesForSpace(
func (c *Service) ListGitspacesWithInstance(
ctx context.Context,
space *types.Space,
filter types.GitspaceFilter,
) ([]*types.GitspaceConfig, int64, int64, error) {
var gitspaceConfigs []*types.GitspaceConfig
var filterCount, allGitspacesInSpaceCount int64
var filterCount, allGitspacesCount int64
err := c.tx.WithTx(ctx, func(ctx context.Context) (err error) {
gitspaceConfigs, err = c.gitspaceConfigStore.ListWithLatestInstance(ctx, &filter)
if err != nil {
@ -86,13 +86,14 @@ func (c *Service) ListGitspacesForSpace(
return fmt.Errorf("failed to filterCount gitspaces in space: %w", err)
}
// Only filter from RBAC and Space is applied for this count, the user filter will be empty for admin users.
allGitspacesInSpaceCount, err = c.gitspaceConfigStore.Count(ctx, &types.GitspaceFilter{
Deleted: filter.Deleted,
MarkedForDeletion: filter.MarkedForDeletion,
GitspaceInstanceFilter: types.GitspaceInstanceFilter{
UserIdentifier: filter.UserIdentifier,
SpaceIDs: filter.SpaceIDs,
},
instanceFilter := types.GitspaceInstanceFilter{
UserIdentifier: filter.UserIdentifier,
SpaceIDs: filter.SpaceIDs,
}
allGitspacesCount, err = c.gitspaceConfigStore.Count(ctx, &types.GitspaceFilter{
Deleted: filter.Deleted,
MarkedForDeletion: filter.MarkedForDeletion,
GitspaceInstanceFilter: instanceFilter,
})
if err != nil {
return fmt.Errorf("failed to count all gitspace configs in space: %w", err)
@ -105,15 +106,18 @@ func (c *Service) ListGitspacesForSpace(
}
for _, gitspaceConfig := range gitspaceConfigs {
space, err := c.spaceStore.FindByRef(ctx, strconv.FormatInt(gitspaceConfig.SpaceID, 10))
if err != nil {
return nil, 0, 0, err
}
gitspaceConfig.SpacePath = space.Path
if gitspaceConfig.GitspaceInstance != nil {
gitspaceConfig.GitspaceInstance.SpacePath = space.Path
}
gitspaceConfig.BranchURL = c.GetBranchURL(ctx, gitspaceConfig)
}
return gitspaceConfigs, filterCount, allGitspacesInSpaceCount, nil
return gitspaceConfigs, filterCount, allGitspacesCount, nil
}
func (c *Service) GetBranchURL(ctx context.Context, config *types.GitspaceConfig) string {
@ -126,3 +130,7 @@ func (c *Service) GetBranchURL(ctx context.Context, config *types.GitspaceConfig
}
return branchURL
}
func (c *Service) Create(ctx context.Context, config *types.GitspaceConfig) error {
return c.gitspaceConfigStore.Create(ctx, config)
}

2
app/services/gitspaceinfraevent/handler.go
View File

@ -129,7 +129,7 @@ func (s *Service) getConfig(
spaceRef string,
identifier string,
) (*types.GitspaceConfig, error) {
config, err := s.gitspaceSvc.Find(ctx, spaceRef, identifier)
config, err := s.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier)
if err != nil {
return nil, fmt.Errorf(
"failed to find gitspace config during infra event handling, identifier %s: %w", identifier, err)

4
cmd/gitness/wire_gen.go
View File

@ -423,9 +423,9 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro
uploadController := upload.ProvideController(authorizer, repoFinder, blobStore)
searcher := keywordsearch.ProvideSearcher(localIndexSearcher)
keywordsearchController := keywordsearch2.ProvideController(authorizer, searcher, repoController, spaceController)
infraproviderController := infraprovider3.ProvideController(authorizer, spaceStore, infraproviderService)
infraproviderController := infraprovider3.ProvideController(authorizer, spaceCache, infraproviderService)
limiterGitspace := limiter.ProvideGitspaceLimiter()
gitspaceController := gitspace2.ProvideController(transactor, authorizer, infraproviderService, gitspaceConfigStore, gitspaceInstanceStore, spaceStore, gitspaceEventStore, statefulLogger, scmSCM, gitspaceService, limiterGitspace, repoFinder)
gitspaceController := gitspace2.ProvideController(transactor, authorizer, infraproviderService, spaceCache, gitspaceEventStore, statefulLogger, scmSCM, gitspaceService, limiterGitspace, repoFinder)
rule := migrate.ProvideRuleImporter(ruleStore, transactor, principalStore)
migrateWebhook := migrate.ProvideWebhookImporter(webhookConfig, transactor, webhookStore)
migrateLabel := migrate.ProvideLabelImporter(transactor, labelStore, labelValueStore, spaceStore)