From b0de915ae23c18c36916c78f6e0cecca35a24983 Mon Sep 17 00:00:00 2001 From: Dhruv Dhruv Date: Tue, 18 Mar 2025 08:00:25 +0000 Subject: [PATCH] feat: [CDE-669]: Integrating gitspaces and infra providers with delete spaces functionality. (#3558) * Addressing review comments. * Rebasing * Removing reliance on space paths for gitspace service. * feat: [CDE-669]: Integrating gitspaces and infra providers with soft delete spaces functionality. --- app/api/controller/gitspace/action.go | 2 +- app/api/controller/gitspace/delete.go | 33 +------ app/api/controller/gitspace/find.go | 2 +- app/api/controller/gitspace/list_all.go | 4 +- app/api/controller/gitspace/logs_stream.go | 2 +- app/api/controller/gitspace/update.go | 2 +- .../controller/infraprovider/delete_config.go | 2 +- app/api/controller/infraprovider/list.go | 5 +- app/api/controller/space/controller.go | 4 + app/api/controller/space/list_gitspaces.go | 10 +-- app/api/controller/space/soft_delete.go | 25 +++++- app/api/controller/space/wire.go | 3 + .../handler/gitspace/list_all_gitspaces.go | 2 +- app/events/gitspace/events.go | 4 +- app/events/gitspacedelete/category.go | 20 +++++ app/events/gitspacedelete/events.go | 65 ++++++++++++++ app/events/gitspacedelete/reader.go | 38 ++++++++ app/events/gitspacedelete/reporter.go | 37 ++++++++ app/events/gitspacedelete/wire.go | 35 ++++++++ app/gitspace/infrastructure/find.go | 10 +-- app/services/gitspace/action_delete.go | 35 ++++++++ app/services/gitspace/actions.go | 2 +- .../gitspace/delete_all_for_spaces.go | 58 ++++++++++++ app/services/gitspace/find.go | 43 +++++---- app/services/gitspace/gitspace.go | 58 +++++++----- app/services/gitspace/wire.go | 4 +- app/services/gitspacedeleteevent/handler.go | 48 ++++++++++ app/services/gitspacedeleteevent/service.go | 89 +++++++++++++++++++ app/services/gitspacedeleteevent/wire.go | 43 +++++++++ app/services/gitspaceinfraevent/handler.go | 8 +- .../gitspaceoperationsevent/handler.go | 3 +- app/services/infraprovider/create_config.go | 4 +- .../infraprovider/delete_all_for_spaces.go | 74 +++++++++++++++ app/services/infraprovider/delete_config.go | 17 ++-- app/services/infraprovider/delete_resource.go | 12 ++- app/services/infraprovider/list.go | 10 ++- app/services/wire.go | 4 + app/store/database.go | 2 +- app/store/database/infra_provider_config.go | 17 +++- cli/operations/server/config.go | 11 +++ cmd/gitness/wire.go | 5 ++ cmd/gitness/wire_gen.go | 63 ++++++++----- types/infra_provider.go | 4 +- 43 files changed, 772 insertions(+), 147 deletions(-) create mode 100644 app/events/gitspacedelete/category.go create mode 100644 app/events/gitspacedelete/events.go create mode 100644 app/events/gitspacedelete/reader.go create mode 100644 app/events/gitspacedelete/reporter.go create mode 100644 app/events/gitspacedelete/wire.go create mode 100644 app/services/gitspace/delete_all_for_spaces.go create mode 100644 app/services/gitspacedeleteevent/handler.go create mode 100644 app/services/gitspacedeleteevent/service.go create mode 100644 app/services/gitspacedeleteevent/wire.go create mode 100644 app/services/infraprovider/delete_all_for_spaces.go diff --git a/app/api/controller/gitspace/action.go b/app/api/controller/gitspace/action.go index 1d304957a..13d263b3b 100644 --- a/app/api/controller/gitspace/action.go +++ b/app/api/controller/gitspace/action.go @@ -51,7 +51,7 @@ func (c *Controller) Action( return nil, fmt.Errorf("failed to authorize: %w", err) } - gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, space.Path, in.Identifier) + gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, space.ID, space.Path, in.Identifier) if err != nil { return nil, fmt.Errorf("failed to find gitspace config: %w", err) } diff --git a/app/api/controller/gitspace/delete.go b/app/api/controller/gitspace/delete.go index 1c607e4c1..4a4db5382 100644 --- a/app/api/controller/gitspace/delete.go +++ b/app/api/controller/gitspace/delete.go @@ -21,8 +21,6 @@ import ( apiauth "github.com/harness/gitness/app/api/auth" "github.com/harness/gitness/app/auth" "github.com/harness/gitness/types/enum" - - "github.com/rs/zerolog/log" ) func (c *Controller) Delete( @@ -36,34 +34,5 @@ func (c *Controller) Delete( return fmt.Errorf("failed to authorize: %w", err) } - 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 - } - instance := gitspaceConfig.GitspaceInstance - if instance == nil || instance.State == enum.GitspaceInstanceStateUninitialized { - gitspaceConfig.IsMarkedForDeletion = true - gitspaceConfig.IsDeleted = true - if err = c.gitspaceSvc.UpdateConfig(ctx, gitspaceConfig); err != nil { - return fmt.Errorf("failed to mark gitspace config as deleted: %w", err) - } - - return nil - } - - // mark can_delete for gitconfig as true so that if delete operation fails, cron job can clean up resources. - gitspaceConfig.IsMarkedForDeletion = true - if err = c.gitspaceSvc.UpdateConfig(ctx, gitspaceConfig); err != nil { - return fmt.Errorf("failed to mark gitspace config is_marked_for_deletion column: %w", err) - } - - ctxWithoutCancel := context.WithoutCancel(ctx) - go func() { - err2 := c.gitspaceSvc.RemoveGitspace(ctxWithoutCancel, *gitspaceConfig, true) - if err2 != nil { - log.Debug().Err(err2).Msgf("unable to Delete gitspace: " + identifier) - } - }() - return nil + return c.gitspaceSvc.DeleteGitspaceByIdentifier(ctx, spaceRef, identifier) } diff --git a/app/api/controller/gitspace/find.go b/app/api/controller/gitspace/find.go index e10aa264d..4ea9c7052 100644 --- a/app/api/controller/gitspace/find.go +++ b/app/api/controller/gitspace/find.go @@ -35,7 +35,7 @@ func (c *Controller) Find( return nil, fmt.Errorf("failed to authorize: %w", err) } - res, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier) + res, err := c.gitspaceSvc.FindWithLatestInstanceWithSpacePath(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 index 13657a7de..966d3258c 100644 --- a/app/api/controller/gitspace/list_all.go +++ b/app/api/controller/gitspace/list_all.go @@ -30,11 +30,11 @@ import ( func (c *Controller) ListAllGitspaces( // nolint:gocognit ctx context.Context, session *auth.Session, - filter *types.GitspaceFilter, + filter types.GitspaceFilter, ) ([]*types.GitspaceConfig, error) { var result []*types.GitspaceConfig err := c.tx.WithTx(ctx, func(ctx context.Context) (err error) { - allGitspaceConfigs, _, _, err := c.gitspaceSvc.ListGitspacesWithInstance(ctx, *filter) + allGitspaceConfigs, _, _, err := c.gitspaceSvc.ListGitspacesWithInstance(ctx, filter, false) if err != nil { return fmt.Errorf("failed to list gitspace configs: %w", err) } diff --git a/app/api/controller/gitspace/logs_stream.go b/app/api/controller/gitspace/logs_stream.go index 2cc77c272..e24e8efa7 100644 --- a/app/api/controller/gitspace/logs_stream.go +++ b/app/api/controller/gitspace/logs_stream.go @@ -37,7 +37,7 @@ func (c *Controller) LogsStream( return nil, nil, fmt.Errorf("failed to authorize: %w", err) } - gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier) + gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstanceWithSpacePath(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/update.go b/app/api/controller/gitspace/update.go index 257a395ca..0aa8e59fc 100644 --- a/app/api/controller/gitspace/update.go +++ b/app/api/controller/gitspace/update.go @@ -52,7 +52,7 @@ func (c *Controller) Update( return fmt.Errorf("failed to authorize: %w", err) } - gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier) + gitspaceConfig, err := c.gitspaceSvc.FindWithLatestInstanceWithSpacePath(ctx, spaceRef, identifier) if err != nil { return fmt.Errorf("failed to find gitspace config: %w", err) } diff --git a/app/api/controller/infraprovider/delete_config.go b/app/api/controller/infraprovider/delete_config.go index e9ea585b5..99540e4db 100644 --- a/app/api/controller/infraprovider/delete_config.go +++ b/app/api/controller/infraprovider/delete_config.go @@ -37,5 +37,5 @@ func (c *Controller) DeleteConfig( if err != nil { return fmt.Errorf("failed to authorize: %w", err) } - return c.infraproviderSvc.DeleteConfig(ctx, space, identifier) + return c.infraproviderSvc.DeleteConfig(ctx, space, identifier, true) } diff --git a/app/api/controller/infraprovider/list.go b/app/api/controller/infraprovider/list.go index 9b394a338..12c22701e 100644 --- a/app/api/controller/infraprovider/list.go +++ b/app/api/controller/infraprovider/list.go @@ -37,5 +37,8 @@ func (c *Controller) List( if err != nil { return nil, fmt.Errorf("failed to authorize: %w", err) } - return c.infraproviderSvc.List(ctx, space) + filter := types.InfraProviderConfigFilter{ + SpaceIDs: []int64{space.ID}, + } + return c.infraproviderSvc.List(ctx, &filter) } diff --git a/app/api/controller/space/controller.go b/app/api/controller/space/controller.go index 6e4564f90..a976c2606 100644 --- a/app/api/controller/space/controller.go +++ b/app/api/controller/space/controller.go @@ -30,6 +30,7 @@ import ( "github.com/harness/gitness/app/services/exporter" "github.com/harness/gitness/app/services/gitspace" "github.com/harness/gitness/app/services/importer" + "github.com/harness/gitness/app/services/infraprovider" "github.com/harness/gitness/app/services/instrument" "github.com/harness/gitness/app/services/label" "github.com/harness/gitness/app/services/publicaccess" @@ -103,6 +104,7 @@ type Controller struct { rulesSvc *rules.Service usageMetricStore store.UsageMetricStore repoIdentifierCheck check.RepoIdentifier + infraProviderSvc *infraprovider.Service } func NewController(config *types.Config, tx dbtx.Transactor, urlProvider url.Provider, @@ -117,6 +119,7 @@ func NewController(config *types.Config, tx dbtx.Transactor, urlProvider url.Pro gitspaceSvc *gitspace.Service, labelSvc *label.Service, instrumentation instrument.Service, executionStore store.ExecutionStore, rulesSvc *rules.Service, usageMetricStore store.UsageMetricStore, repoIdentifierCheck check.RepoIdentifier, + infraProviderSvc *infraprovider.Service, ) *Controller { return &Controller{ nestedSpacesEnabled: config.NestedSpacesEnabled, @@ -149,6 +152,7 @@ func NewController(config *types.Config, tx dbtx.Transactor, urlProvider url.Pro rulesSvc: rulesSvc, usageMetricStore: usageMetricStore, repoIdentifierCheck: repoIdentifierCheck, + infraProviderSvc: infraProviderSvc, } } diff --git a/app/api/controller/space/list_gitspaces.go b/app/api/controller/space/list_gitspaces.go index d439d323a..c6d8eff89 100644 --- a/app/api/controller/space/list_gitspaces.go +++ b/app/api/controller/space/list_gitspaces.go @@ -22,6 +22,8 @@ import ( "github.com/harness/gitness/app/auth" "github.com/harness/gitness/types" "github.com/harness/gitness/types/enum" + + "github.com/gotidy/ptr" ) func (c *Controller) ListGitspaces( @@ -42,10 +44,8 @@ func (c *Controller) ListGitspaces( filter.UserIdentifier = session.Principal.UID filter.SpaceIDs = []int64{space.ID} - deleted := false - markedForDeletion := false - filter.Deleted = &deleted - filter.MarkedForDeletion = &markedForDeletion + filter.Deleted = ptr.Bool(false) + filter.MarkedForDeletion = ptr.Bool(false) - return c.gitspaceSvc.ListGitspacesWithInstance(ctx, filter) + return c.gitspaceSvc.ListGitspacesWithInstance(ctx, filter, true) } diff --git a/app/api/controller/space/soft_delete.go b/app/api/controller/space/soft_delete.go index 097da6797..38379e324 100644 --- a/app/api/controller/space/soft_delete.go +++ b/app/api/controller/space/soft_delete.go @@ -97,8 +97,25 @@ func (c *Controller) softDeleteInnerInTx( return nil, fmt.Errorf("failed to list space %d sub spaces recursively: %w", space.ID, err) } + allSpaces := []*types.Space{space} + allSpaces = append(allSpaces, subSpaces...) + now := time.Now().UnixMilli() + if c.gitspaceSvc != nil { + err = c.gitspaceSvc.DeleteAllForSpaces(ctx, allSpaces) + if err != nil { + return nil, fmt.Errorf("failed to soft delete gitspaces of space %d: %w", space.ID, err) + } + } + + if c.infraProviderSvc != nil { + err = c.infraProviderSvc.DeleteAllForSpaces(ctx, allSpaces) + if err != nil { + return nil, fmt.Errorf("failed to soft delete infra providers of space %d: %w", space.ID, err) + } + } + for _, space := range subSpaces { _, err := c.spaceStore.FindForUpdate(ctx, space.ID) if err != nil { @@ -110,9 +127,11 @@ func (c *Controller) softDeleteInnerInTx( } } - err = c.softDeleteRepositoriesNoAuth(ctx, session, space.ID, now) - if err != nil { - return nil, fmt.Errorf("failed to soft delete repositories of space %d: %w", space.ID, err) + if c.repoStore != nil && c.repoCtrl != nil { + err = c.softDeleteRepositoriesNoAuth(ctx, session, space.ID, now) + if err != nil { + return nil, fmt.Errorf("failed to soft delete repositories of space %d: %w", space.ID, err) + } } if err = c.spaceStore.SoftDelete(ctx, space, now); err != nil { diff --git a/app/api/controller/space/wire.go b/app/api/controller/space/wire.go index ccaa95a12..468eb8f17 100644 --- a/app/api/controller/space/wire.go +++ b/app/api/controller/space/wire.go @@ -21,6 +21,7 @@ import ( "github.com/harness/gitness/app/services/exporter" "github.com/harness/gitness/app/services/gitspace" "github.com/harness/gitness/app/services/importer" + infraprovider2 "github.com/harness/gitness/app/services/infraprovider" "github.com/harness/gitness/app/services/instrument" "github.com/harness/gitness/app/services/label" "github.com/harness/gitness/app/services/publicaccess" @@ -55,6 +56,7 @@ func ProvideController(config *types.Config, tx dbtx.Transactor, urlProvider url auditService audit.Service, gitspaceService *gitspace.Service, labelSvc *label.Service, instrumentation instrument.Service, executionStore store.ExecutionStore, rulesSvc *rules.Service, usageMetricStore store.UsageMetricStore, repoIdentifierCheck check.RepoIdentifier, + infraProviderSvc *infraprovider2.Service, ) *Controller { return NewController(config, tx, urlProvider, sseStreamer, identifierCheck, authorizer, @@ -67,5 +69,6 @@ func ProvideController(config *types.Config, tx dbtx.Transactor, urlProvider url auditService, gitspaceService, labelSvc, instrumentation, executionStore, rulesSvc, usageMetricStore, repoIdentifierCheck, + infraProviderSvc, ) } diff --git a/app/api/handler/gitspace/list_all_gitspaces.go b/app/api/handler/gitspace/list_all_gitspaces.go index 00884d2bf..c4823b201 100644 --- a/app/api/handler/gitspace/list_all_gitspaces.go +++ b/app/api/handler/gitspace/list_all_gitspaces.go @@ -30,7 +30,7 @@ func HandleListAllGitspaces(gitspaceCtrl *gitspace.Controller) http.HandlerFunc session, _ := request.AuthSessionFrom(ctx) deleted := false markedForDeletion := false - filter := &types.GitspaceFilter{ + filter := types.GitspaceFilter{ GitspaceInstanceFilter: types.GitspaceInstanceFilter{UserIdentifier: session.Principal.UID}, Deleted: &deleted, MarkedForDeletion: &markedForDeletion, diff --git a/app/events/gitspace/events.go b/app/events/gitspace/events.go index e62a4024b..3848b455c 100644 --- a/app/events/gitspace/events.go +++ b/app/events/gitspace/events.go @@ -45,11 +45,11 @@ func (r *Reporter) EmitGitspaceEvent(ctx context.Context, event events.EventType } eventID, err := events.ReporterSendEvent(r.innerReporter, ctx, event, payload) if err != nil { - log.Ctx(ctx).Err(err).Msgf("failed to send %v event", event) + log.Ctx(ctx).Err(err).Msgf("failed to send %s event", event) return } - log.Ctx(ctx).Debug().Msgf("reported %v event with id '%s'", event, eventID) + log.Ctx(ctx).Debug().Msgf("reported %s event with id '%s'", event, eventID) } func (r *Reader) RegisterGitspaceEvent( diff --git a/app/events/gitspacedelete/category.go b/app/events/gitspacedelete/category.go new file mode 100644 index 000000000..82b08427a --- /dev/null +++ b/app/events/gitspacedelete/category.go @@ -0,0 +1,20 @@ +// Copyright 2023 Harness, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package events + +const ( + // category defines the event category used for this package. + category = "gitspace_delete" +) diff --git a/app/events/gitspacedelete/events.go b/app/events/gitspacedelete/events.go new file mode 100644 index 000000000..6562300d9 --- /dev/null +++ b/app/events/gitspacedelete/events.go @@ -0,0 +1,65 @@ +// Copyright 2023 Harness, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package events + +import ( + "context" + + "github.com/harness/gitness/events" + + "github.com/rs/zerolog/log" +) + +const ( + GitspaceDeleteEvent events.EventType = "gitspace_delete_event" +) + +type ( + GitspaceDeleteEventPayload struct { + GitspaceConfigIdentifier string `json:"gitspace_config_identifier"` + SpaceID int64 `json:"space_id"` + } +) + +func (r *Reporter) EmitGitspaceDeleteEvent( + ctx context.Context, + event events.EventType, + payload *GitspaceDeleteEventPayload, +) { + if payload == nil { + return + } + + if event != GitspaceDeleteEvent { + log.Ctx(ctx).Error().Msgf("event type should be %s, got %s, aborting emission, payload: %+v", + GitspaceDeleteEvent, event, payload) + return + } + + eventID, err := events.ReporterSendEvent(r.innerReporter, ctx, event, payload) + if err != nil { + log.Ctx(ctx).Err(err).Msgf("failed to send %s event", event) + return + } + + log.Ctx(ctx).Debug().Msgf("reported %s event with id '%s'", event, eventID) +} + +func (r *Reader) RegisterGitspaceDeleteEvent( + fn events.HandlerFunc[*GitspaceDeleteEventPayload], + opts ...events.HandlerOption, +) error { + return events.ReaderRegisterEvent(r.innerReader, GitspaceDeleteEvent, fn, opts...) +} diff --git a/app/events/gitspacedelete/reader.go b/app/events/gitspacedelete/reader.go new file mode 100644 index 000000000..27b39a9c5 --- /dev/null +++ b/app/events/gitspacedelete/reader.go @@ -0,0 +1,38 @@ +// Copyright 2023 Harness, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package events + +import ( + "github.com/harness/gitness/events" +) + +func NewReaderFactory(eventsSystem *events.System) (*events.ReaderFactory[*Reader], error) { + readerFactoryFunc := func(innerReader *events.GenericReader) (*Reader, error) { + return &Reader{ + innerReader: innerReader, + }, nil + } + + return events.NewReaderFactory(eventsSystem, category, readerFactoryFunc) +} + +// Reader is the event reader for this package. +type Reader struct { + innerReader *events.GenericReader +} + +func (r *Reader) Configure(opts ...events.ReaderOption) { + r.innerReader.Configure(opts...) +} diff --git a/app/events/gitspacedelete/reporter.go b/app/events/gitspacedelete/reporter.go new file mode 100644 index 000000000..68fdecaad --- /dev/null +++ b/app/events/gitspacedelete/reporter.go @@ -0,0 +1,37 @@ +// Copyright 2023 Harness, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package events + +import ( + "errors" + + "github.com/harness/gitness/events" +) + +// Reporter is the event reporter for this package. +type Reporter struct { + innerReporter *events.GenericReporter +} + +func NewReporter(eventsSystem *events.System) (*Reporter, error) { + innerReporter, err := events.NewReporter(eventsSystem, category) + if err != nil { + return nil, errors.New("failed to create new GenericReporter from event system") + } + + return &Reporter{ + innerReporter: innerReporter, + }, nil +} diff --git a/app/events/gitspacedelete/wire.go b/app/events/gitspacedelete/wire.go new file mode 100644 index 000000000..215800d79 --- /dev/null +++ b/app/events/gitspacedelete/wire.go @@ -0,0 +1,35 @@ +// Copyright 2023 Harness, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package events + +import ( + "github.com/harness/gitness/events" + + "github.com/google/wire" +) + +// WireSet provides a wire set for this package. +var WireSet = wire.NewSet( + ProvideReaderFactory, + ProvideReporter, +) + +func ProvideReaderFactory(eventsSystem *events.System) (*events.ReaderFactory[*Reader], error) { + return NewReaderFactory(eventsSystem) +} + +func ProvideReporter(eventsSystem *events.System) (*Reporter, error) { + return NewReporter(eventsSystem) +} diff --git a/app/gitspace/infrastructure/find.go b/app/gitspace/infrastructure/find.go index 09025398d..a8d45a01e 100644 --- a/app/gitspace/infrastructure/find.go +++ b/app/gitspace/infrastructure/find.go @@ -92,8 +92,8 @@ func (i InfraProvisioner) paramsForProvisioningTypeNew( ctx context.Context, gitspaceConfig types.GitspaceConfig, ) ([]types.InfraProviderParameter, map[string]any, error) { - infraProvisionedLatest, err := i.infraProvisionedStore.FindLatestByGitspaceInstanceID( - ctx, gitspaceConfig.GitspaceInstance.ID) + infraProvisionedLatest, err := i.infraProvisionedStore.FindLatestByGitspaceInstanceID(ctx, + gitspaceConfig.GitspaceInstance.ID) if err != nil { return nil, nil, fmt.Errorf( "could not find latest infra provisioned entity for instance %d: %w", @@ -107,7 +107,7 @@ func (i InfraProvisioner) paramsForProvisioningTypeNew( return nil, nil, err } infraProviderConfig, err := i.infraProviderConfigStore.Find(ctx, - gitspaceConfig.InfraProviderResource.InfraProviderConfigID) + gitspaceConfig.InfraProviderResource.InfraProviderConfigID, true) if err != nil { return nil, nil, err } @@ -174,7 +174,7 @@ func (i InfraProvisioner) getConfigFromResource( ctx context.Context, infraProviderResource types.InfraProviderResource, ) (*types.InfraProviderConfig, error) { - config, err := i.infraProviderConfigStore.Find(ctx, infraProviderResource.InfraProviderConfigID) + config, err := i.infraProviderConfigStore.Find(ctx, infraProviderResource.InfraProviderConfigID, true) if err != nil { return nil, fmt.Errorf( "unable to get infra provider details for ID %d: %w", @@ -278,7 +278,7 @@ func (i InfraProvisioner) configMetadata( ctx context.Context, infraProviderResource types.InfraProviderResource, ) (map[string]any, error) { - infraProviderConfig, err := i.infraProviderConfigStore.Find(ctx, infraProviderResource.InfraProviderConfigID) + infraProviderConfig, err := i.infraProviderConfigStore.Find(ctx, infraProviderResource.InfraProviderConfigID, true) if err != nil { return nil, err } diff --git a/app/services/gitspace/action_delete.go b/app/services/gitspace/action_delete.go index 73f99da11..689edb9aa 100644 --- a/app/services/gitspace/action_delete.go +++ b/app/services/gitspace/action_delete.go @@ -19,12 +19,47 @@ import ( "fmt" "time" + events "github.com/harness/gitness/app/events/gitspacedelete" "github.com/harness/gitness/types" "github.com/harness/gitness/types/enum" "github.com/rs/zerolog/log" ) +func (c *Service) DeleteGitspaceByIdentifier(ctx context.Context, spaceRef string, identifier string) error { + gitspaceConfig, err := c.FindWithLatestInstanceWithSpacePath(ctx, spaceRef, identifier) + if err != nil { + log.Err(err).Msgf("Failed to find latest gitspace config : %s", identifier) + return err + } + return c.deleteGitspace(ctx, gitspaceConfig) +} + +func (c *Service) deleteGitspace(ctx context.Context, gitspaceConfig *types.GitspaceConfig) error { + if gitspaceConfig.GitspaceInstance == nil || + gitspaceConfig.GitspaceInstance.State == enum.GitspaceInstanceStateUninitialized { + gitspaceConfig.IsMarkedForDeletion = true + gitspaceConfig.IsDeleted = true + if err := c.UpdateConfig(ctx, gitspaceConfig); err != nil { + return fmt.Errorf("failed to mark gitspace config as deleted: %w", err) + } + + return nil + } + + // mark can_delete for gitconfig as true so that if delete operation fails, cron job can clean up resources. + gitspaceConfig.IsMarkedForDeletion = true + if err := c.UpdateConfig(ctx, gitspaceConfig); err != nil { + return fmt.Errorf("failed to mark gitspace config is_marked_for_deletion column: %w", err) + } + + c.gitspaceDeleteEventReporter.EmitGitspaceDeleteEvent(ctx, events.GitspaceDeleteEvent, + &events.GitspaceDeleteEventPayload{GitspaceConfigIdentifier: gitspaceConfig.Identifier, + SpaceID: gitspaceConfig.SpaceID}) + + return nil +} + func (c *Service) RemoveGitspace(ctx context.Context, config types.GitspaceConfig, canDeleteUserData bool) error { if config.GitspaceInstance.State == enum.GitSpaceInstanceStateCleaning && time.Since(time.UnixMilli(config.GitspaceInstance.Updated)).Milliseconds() <= diff --git a/app/services/gitspace/actions.go b/app/services/gitspace/actions.go index abb2f3238..922c484e4 100644 --- a/app/services/gitspace/actions.go +++ b/app/services/gitspace/actions.go @@ -170,7 +170,7 @@ func (c *Service) EmitGitspaceConfigEvent( config types.GitspaceConfig, eventType enum.GitspaceEventType, ) { - c.eventReporter.EmitGitspaceEvent(ctx, events.GitspaceEvent, &events.GitspaceEventPayload{ + c.gitspaceEventReporter.EmitGitspaceEvent(ctx, events.GitspaceEvent, &events.GitspaceEventPayload{ QueryKey: config.Identifier, EntityID: config.ID, EntityType: enum.GitspaceEntityTypeGitspaceConfig, diff --git a/app/services/gitspace/delete_all_for_spaces.go b/app/services/gitspace/delete_all_for_spaces.go new file mode 100644 index 000000000..50f378632 --- /dev/null +++ b/app/services/gitspace/delete_all_for_spaces.go @@ -0,0 +1,58 @@ +// Copyright 2023 Harness, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package gitspace + +import ( + "context" + "fmt" + + "github.com/harness/gitness/types" + + "github.com/gotidy/ptr" + "github.com/rs/zerolog/log" +) + +func (c *Service) DeleteAllForSpaces(ctx context.Context, spaces []*types.Space) error { + spaceIDs := make([]int64, 0, len(spaces)) + for _, space := range spaces { + spaceIDs = append(spaceIDs, space.ID) + } + + log.Debug().Msgf("Deleting all gitspaces for spaces %+v", spaceIDs) + + var gitspaceFilter = types.GitspaceFilter{} + gitspaceFilter.SpaceIDs = spaceIDs + gitspaceFilter.Deleted = ptr.Bool(false) + gitspaceFilter.MarkedForDeletion = ptr.Bool(false) + + gitspaces, _, _, err := c.ListGitspacesWithInstance(ctx, gitspaceFilter, false) + if err != nil { + return fmt.Errorf("error while listing gitspaces with instance before deleting all for spaces: %w", err) + } + + for _, gitspace := range gitspaces { + log.Debug().Msgf("Deleting gitspace %s for space %d", gitspace.Identifier, gitspace.SpaceID) + err = c.deleteGitspace(ctx, gitspace) + if err != nil { + return fmt.Errorf("error while deleting gitspace %s while deleting all for spaces: %w", + gitspace.Identifier, err) + } + log.Debug().Msgf("Deleted gitspace %s for space %d", gitspace.Identifier, gitspace.SpaceID) + } + + log.Debug().Msgf("Deleted all gitspaces for spaces %+v", spaceIDs) + + return nil +} diff --git a/app/services/gitspace/find.go b/app/services/gitspace/find.go index cc52e0ccd..725151534 100644 --- a/app/services/gitspace/find.go +++ b/app/services/gitspace/find.go @@ -24,26 +24,36 @@ import ( "github.com/harness/gitness/store/database/dbtx" "github.com/harness/gitness/types" "github.com/harness/gitness/types/enum" + + "github.com/rs/zerolog/log" ) -func (c *Service) FindWithLatestInstance( +func (c *Service) FindWithLatestInstanceWithSpacePath( ctx context.Context, - spaceRef string, + spacePath string, identifier string, ) (*types.GitspaceConfig, error) { - space, err := c.spaceFinder.FindByRef(ctx, spaceRef) + space, err := c.spaceFinder.FindByRef(ctx, spacePath) if err != nil { return nil, fmt.Errorf("failed to find space: %w", err) } + return c.FindWithLatestInstance(ctx, space.ID, spacePath, identifier) +} +func (c *Service) FindWithLatestInstance( + ctx context.Context, + spaceID int64, + spacePath string, + identifier string, +) (*types.GitspaceConfig, error) { var gitspaceConfigResult *types.GitspaceConfig txErr := c.tx.WithTx(ctx, func(ctx context.Context) error { - gitspaceConfig, err := c.gitspaceConfigStore.FindByIdentifier(ctx, space.ID, identifier) + gitspaceConfig, err := c.gitspaceConfigStore.FindByIdentifier(ctx, spaceID, identifier) if err != nil { return fmt.Errorf("failed to find gitspace config: %w", err) } gitspaceConfigResult = gitspaceConfig - if err = c.setInstance(ctx, gitspaceConfigResult, space); err != nil { + if err = c.setInstance(ctx, gitspaceConfigResult); err != nil { return err } return nil @@ -52,19 +62,28 @@ func (c *Service) FindWithLatestInstance( return nil, txErr } gitspaceConfigResult.BranchURL = c.GetBranchURL(ctx, gitspaceConfigResult) + + if spacePath == "" { + space, err := c.spaceFinder.FindByID(ctx, spaceID) + if err != nil { + log.Warn().Err(err).Msgf("failed to find space path for id %d", spaceID) + } else { + spacePath = space.Path + } + } + + gitspaceConfigResult.SpacePath = spacePath return gitspaceConfigResult, nil } func (c *Service) setInstance( ctx context.Context, gitspaceConfig *types.GitspaceConfig, - space *types.SpaceCore, ) error { instance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, gitspaceConfig.ID) if err != nil && !errors.Is(err, store.ErrResourceNotFound) { return err } - gitspaceConfig.SpacePath = space.Path if instance != nil { gitspaceConfig.GitspaceInstance = instance instance.SpacePath = gitspaceConfig.SpacePath @@ -95,7 +114,8 @@ func (c *Service) FindWithLatestInstanceByID( if err != nil { return fmt.Errorf("failed to find space: %w", err) } - return c.setInstance(ctx, gitspaceConfigResult, space) + gitspaceConfigResult.SpacePath = space.Path + return c.setInstance(ctx, gitspaceConfigResult) }, dbtx.TxDefaultReadOnly) if txErr != nil { return nil, txErr @@ -134,21 +154,14 @@ func (c *Service) FindAll( func (c *Service) FindInstanceByIdentifier( ctx context.Context, identifier string, - spaceRef string, ) (*types.GitspaceInstance, error) { var gitspaceInstanceResult *types.GitspaceInstance txErr := c.tx.WithTx(ctx, func(ctx context.Context) error { - space, err := c.spaceFinder.FindByRef(ctx, spaceRef) - if err != nil { - return fmt.Errorf("failed to find space: %w", err) - } gitspaceInstance, err := c.gitspaceInstanceStore.FindByIdentifier(ctx, identifier) if err != nil { return fmt.Errorf("failed to find gitspace instance: %w", err) } gitspaceInstanceResult = gitspaceInstance - gitspaceInstanceResult.SpacePath = space.Path - return nil }, dbtx.TxDefaultReadOnly) if txErr != nil { diff --git a/app/services/gitspace/gitspace.go b/app/services/gitspace/gitspace.go index cdb8de716..4ef1d2f2e 100644 --- a/app/services/gitspace/gitspace.go +++ b/app/services/gitspace/gitspace.go @@ -20,6 +20,7 @@ import ( "strconv" gitspaceevents "github.com/harness/gitness/app/events/gitspace" + gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete" "github.com/harness/gitness/app/gitspace/orchestrator" "github.com/harness/gitness/app/gitspace/scm" "github.com/harness/gitness/app/services/infraprovider" @@ -42,41 +43,47 @@ func NewService( orchestrator orchestrator.Orchestrator, scm *scm.SCM, config *types.Config, + gitspaceDeleteEventReporter *gitspacedeleteevents.Reporter, ) *Service { return &Service{ - tx: tx, - gitspaceConfigStore: gitspaceStore, - gitspaceInstanceStore: gitspaceInstanceStore, - eventReporter: eventReporter, - gitspaceEventStore: gitspaceEventStore, - spaceFinder: spaceFinder, - infraProviderSvc: infraProviderSvc, - orchestrator: orchestrator, - scm: scm, - config: config, + tx: tx, + gitspaceConfigStore: gitspaceStore, + gitspaceInstanceStore: gitspaceInstanceStore, + gitspaceEventReporter: eventReporter, + gitspaceEventStore: gitspaceEventStore, + spaceFinder: spaceFinder, + infraProviderSvc: infraProviderSvc, + orchestrator: orchestrator, + scm: scm, + config: config, + gitspaceDeleteEventReporter: gitspaceDeleteEventReporter, } } type Service struct { - gitspaceConfigStore store.GitspaceConfigStore - gitspaceInstanceStore store.GitspaceInstanceStore - eventReporter *gitspaceevents.Reporter - gitspaceEventStore store.GitspaceEventStore - spaceFinder refcache.SpaceFinder - tx dbtx.Transactor - infraProviderSvc *infraprovider.Service - orchestrator orchestrator.Orchestrator - scm *scm.SCM - config *types.Config + gitspaceConfigStore store.GitspaceConfigStore + gitspaceInstanceStore store.GitspaceInstanceStore + gitspaceEventReporter *gitspaceevents.Reporter + gitspaceDeleteEventReporter *gitspacedeleteevents.Reporter + gitspaceEventStore store.GitspaceEventStore + spaceFinder refcache.SpaceFinder + tx dbtx.Transactor + infraProviderSvc *infraprovider.Service + orchestrator orchestrator.Orchestrator + scm *scm.SCM + config *types.Config } func (c *Service) ListGitspacesWithInstance( ctx context.Context, filter types.GitspaceFilter, + useTransaction bool, ) ([]*types.GitspaceConfig, int64, int64, error) { var gitspaceConfigs []*types.GitspaceConfig var filterCount, allGitspacesCount int64 - err := c.tx.WithTx(ctx, func(ctx context.Context) (err error) { + var err error + + findFunc := func(ctx context.Context) (err error) { gitspaceConfigs, err = c.gitspaceConfigStore.ListWithLatestInstance(ctx, &filter) if err != nil { return fmt.Errorf("failed to list gitspace configs: %w", err) @@ -101,7 +108,14 @@ func (c *Service) ListGitspacesWithInstance( } return nil - }, dbtx.TxDefaultReadOnly) + } + + if useTransaction { + err = c.tx.WithTx(ctx, findFunc, dbtx.TxDefaultReadOnly) + } else { + err = findFunc(ctx) + } + if err != nil { return nil, 0, 0, err } diff --git a/app/services/gitspace/wire.go b/app/services/gitspace/wire.go index b0c8f8c27..38cf25643 100644 --- a/app/services/gitspace/wire.go +++ b/app/services/gitspace/wire.go @@ -16,6 +16,7 @@ package gitspace import ( gitspaceevents "github.com/harness/gitness/app/events/gitspace" + gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete" "github.com/harness/gitness/app/gitspace/orchestrator" "github.com/harness/gitness/app/gitspace/scm" "github.com/harness/gitness/app/services/infraprovider" @@ -42,7 +43,8 @@ func ProvideGitspace( orchestrator orchestrator.Orchestrator, scm *scm.SCM, config *types.Config, + gitspaceDeleteEventReporter *gitspacedeleteevents.Reporter, ) *Service { return NewService(tx, gitspaceStore, gitspaceInstanceStore, eventReporter, - gitspaceEventStore, spaceFinder, infraProviderSvc, orchestrator, scm, config) + gitspaceEventStore, spaceFinder, infraProviderSvc, orchestrator, scm, config, gitspaceDeleteEventReporter) } diff --git a/app/services/gitspacedeleteevent/handler.go b/app/services/gitspacedeleteevent/handler.go new file mode 100644 index 000000000..3f8d5d1ae --- /dev/null +++ b/app/services/gitspacedeleteevent/handler.go @@ -0,0 +1,48 @@ +// Copyright 2023 Harness, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package gitspacedeleteevent + +import ( + "context" + "fmt" + + gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete" + "github.com/harness/gitness/events" + + "github.com/rs/zerolog/log" +) + +func (s *Service) handleGitspaceDeleteEvent( + ctx context.Context, + event *events.Event[*gitspacedeleteevents.GitspaceDeleteEventPayload], +) error { + log.Debug().Msgf("handling gitspace delete event with payload: %+v", event.Payload) + gitspaceConfigIdentifier := event.Payload.GitspaceConfigIdentifier + spaceID := event.Payload.SpaceID + gitspaceConfig, err := s.gitspaceSvc.FindWithLatestInstance(ctx, spaceID, "", gitspaceConfigIdentifier) + if err != nil { + return fmt.Errorf("failed to find gitspace config %s for space %d while handling delete event: %w", + gitspaceConfigIdentifier, spaceID, err) + } + + err = s.gitspaceSvc.RemoveGitspace(ctx, *gitspaceConfig, true) + if err != nil { + // NOTE: No need to retry from the event handler. The background job will take care. + log.Debug().Err(err).Msgf("unable to delete gitspace: " + gitspaceConfigIdentifier) + } + + log.Debug().Msgf("handled gitspace delete event with payload: %+v", event.Payload) + return nil +} diff --git a/app/services/gitspacedeleteevent/service.go b/app/services/gitspacedeleteevent/service.go new file mode 100644 index 000000000..49628bcd2 --- /dev/null +++ b/app/services/gitspacedeleteevent/service.go @@ -0,0 +1,89 @@ +// Copyright 2023 Harness, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package gitspacedeleteevent + +import ( + "context" + "errors" + "fmt" + "time" + + gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete" + "github.com/harness/gitness/app/services/gitspace" + "github.com/harness/gitness/events" + "github.com/harness/gitness/stream" +) + +const groupGitspaceDeleteEvents = "gitness:gitspace_delete" + +type Config struct { + EventReaderName string + Concurrency int + MaxRetries int + TimeoutInMins int +} + +func (c *Config) Sanitize() error { + if c.EventReaderName == "" { + return errors.New("config.EventReaderName is required") + } + if c.Concurrency < 1 { + return errors.New("config.Concurrency has to be a positive number") + } + if c.MaxRetries < 0 { + return errors.New("config.MaxRetries can't be negative") + } + return nil +} + +type Service struct { + config *Config + gitspaceSvc *gitspace.Service +} + +func NewService( + ctx context.Context, + config *Config, + gitspaceDeleteEventReaderFactory *events.ReaderFactory[*gitspacedeleteevents.Reader], + gitspaceSvc *gitspace.Service, +) (*Service, error) { + if err := config.Sanitize(); err != nil { + return nil, fmt.Errorf("provided gitspace event service config is invalid: %w", err) + } + service := &Service{ + config: config, + gitspaceSvc: gitspaceSvc, + } + + _, err := gitspaceDeleteEventReaderFactory.Launch(ctx, groupGitspaceDeleteEvents, config.EventReaderName, + func(r *gitspacedeleteevents.Reader) error { + var idleTimeout = time.Duration(config.TimeoutInMins) * time.Minute + r.Configure( + stream.WithConcurrency(config.Concurrency), + stream.WithHandlerOptions( + stream.WithIdleTimeout(idleTimeout), + stream.WithMaxRetries(config.MaxRetries), + )) + + _ = r.RegisterGitspaceDeleteEvent(service.handleGitspaceDeleteEvent) + + return nil + }) + if err != nil { + return nil, fmt.Errorf("failed to launch gitspace delete event reader: %w", err) + } + + return service, nil +} diff --git a/app/services/gitspacedeleteevent/wire.go b/app/services/gitspacedeleteevent/wire.go new file mode 100644 index 000000000..20d92b88e --- /dev/null +++ b/app/services/gitspacedeleteevent/wire.go @@ -0,0 +1,43 @@ +// Copyright 2023 Harness, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package gitspacedeleteevent + +import ( + "context" + + gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete" + "github.com/harness/gitness/app/services/gitspace" + "github.com/harness/gitness/events" + + "github.com/google/wire" +) + +// WireSet provides a wire set for this package. +var WireSet = wire.NewSet( + ProvideService, +) + +func ProvideService(ctx context.Context, + config *Config, + gitspaceDeleteEventReaderFactory *events.ReaderFactory[*gitspacedeleteevents.Reader], + gitspaceSvc *gitspace.Service, +) (*Service, error) { + return NewService( + ctx, + config, + gitspaceDeleteEventReaderFactory, + gitspaceSvc, + ) +} diff --git a/app/services/gitspaceinfraevent/handler.go b/app/services/gitspaceinfraevent/handler.go index c3fc55c62..64b9cf986 100644 --- a/app/services/gitspaceinfraevent/handler.go +++ b/app/services/gitspaceinfraevent/handler.go @@ -35,8 +35,7 @@ func (s *Service) handleGitspaceInfraResumeEvent( payload := event.Payload ctxWithTimedOut, cancel := context.WithTimeout(ctx, time.Duration(s.config.TimeoutInMins)*time.Minute) defer cancel() - config, fetchErr := s.getConfig( - ctxWithTimedOut, payload.Infra.SpacePath, payload.Infra.GitspaceConfigIdentifier) + config, fetchErr := s.getConfig(ctxWithTimedOut, payload.Infra.SpaceID, payload.Infra.GitspaceConfigIdentifier) if fetchErr != nil { return fetchErr } @@ -46,7 +45,6 @@ func (s *Service) handleGitspaceInfraResumeEvent( gitspaceInstance, err := s.gitspaceSvc.FindInstanceByIdentifier( ctxWithTimedOut, payload.Infra.GitspaceInstanceIdentifier, - payload.Infra.SpacePath, ) if err != nil { return fmt.Errorf("failed to fetch gitspace instance: %w", err) @@ -127,10 +125,10 @@ func (s *Service) handleGitspaceInfraResumeEvent( func (s *Service) getConfig( ctx context.Context, - spaceRef string, + spaceID int64, identifier string, ) (*types.GitspaceConfig, error) { - config, err := s.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier) + config, err := s.gitspaceSvc.FindWithLatestInstance(ctx, spaceID, "", identifier) if err != nil { return nil, fmt.Errorf( "failed to find gitspace config during infra event handling, identifier %s: %w", identifier, err) diff --git a/app/services/gitspaceoperationsevent/handler.go b/app/services/gitspaceoperationsevent/handler.go index 41a819c24..f2996a4bd 100644 --- a/app/services/gitspaceoperationsevent/handler.go +++ b/app/services/gitspaceoperationsevent/handler.go @@ -50,7 +50,6 @@ func (s *Service) handleGitspaceOperationsEvent( gitspaceInstance, err := s.gitspaceSvc.FindInstanceByIdentifier( ctxWithTimedOut, payload.Infra.GitspaceInstanceIdentifier, - payload.Infra.SpacePath, ) if err != nil { return fmt.Errorf("failed to fetch gitspace instance: %w", err) @@ -131,7 +130,7 @@ func (s *Service) getConfig( spaceRef string, identifier string, ) (*types.GitspaceConfig, error) { - config, err := s.gitspaceSvc.FindWithLatestInstance(ctx, spaceRef, identifier) + config, err := s.gitspaceSvc.FindWithLatestInstanceWithSpacePath(ctx, spaceRef, identifier) if err != nil { return nil, fmt.Errorf( "failed to find gitspace config during infra event handling, identifier %s: %w", identifier, err) diff --git a/app/services/infraprovider/create_config.go b/app/services/infraprovider/create_config.go index a20b9dc0e..572f721a7 100644 --- a/app/services/infraprovider/create_config.go +++ b/app/services/infraprovider/create_config.go @@ -64,8 +64,8 @@ func (c *Service) fetchExistingConfigs( infraProviderConfig *types.InfraProviderConfig, ) ([]*types.InfraProviderConfig, error) { existingConfigs, err := c.infraProviderConfigStore.List(ctx, &types.InfraProviderConfigFilter{ - SpaceID: infraProviderConfig.SpaceID, - Type: infraProviderConfig.Type, + SpaceIDs: []int64{infraProviderConfig.SpaceID}, + Type: infraProviderConfig.Type, }) if err != nil { return nil, fmt.Errorf("failed to find existing infraprovider config for type %s & space %d: %w", diff --git a/app/services/infraprovider/delete_all_for_spaces.go b/app/services/infraprovider/delete_all_for_spaces.go new file mode 100644 index 000000000..d4bf783f0 --- /dev/null +++ b/app/services/infraprovider/delete_all_for_spaces.go @@ -0,0 +1,74 @@ +// Copyright 2023 Harness, Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package infraprovider + +import ( + "context" + "fmt" + + "github.com/harness/gitness/types" + + "github.com/rs/zerolog/log" +) + +func (c *Service) DeleteAllForSpaces(ctx context.Context, spaces []*types.Space) error { + spaceIDsMap := make(map[int64]*types.SpaceCore) + spaceIDs := make([]int64, 0, len(spaces)) + for _, space := range spaces { + spaceIDs = append(spaceIDs, space.ID) + spaceIDsMap[space.ID] = space.Core() + } + + log.Debug().Msgf("Deleting all infra providers for spaces %+v", spaceIDs) + + infraProviderConfigFilter := types.InfraProviderConfigFilter{SpaceIDs: spaceIDs} + infraProviderConfigs, err := c.List(ctx, &infraProviderConfigFilter) + if err != nil { + return fmt.Errorf("error while listing infra provider entities before deleting all for spaces: %w", err) + } + + for _, infraProviderConfig := range infraProviderConfigs { + for _, infraProviderResource := range infraProviderConfig.Resources { + log.Debug().Msgf("Deleting infra resource %s for space %d", infraProviderResource.UID, + infraProviderResource.SpaceID) + + err = c.DeleteResource(ctx, infraProviderConfig.SpaceID, infraProviderConfig.Identifier, + infraProviderResource.UID, false) + if err != nil { + return fmt.Errorf("error while deleting infra resource %s while deleting all for spaces: %w", + infraProviderResource.UID, err) + } + + log.Debug().Msgf("Deleted infra resource %s for space %d", infraProviderResource.UID, + infraProviderResource.SpaceID) + } + + log.Debug().Msgf("Deleting infra config %s for space %d", infraProviderConfig.Identifier, + infraProviderConfig.SpaceID) + + err = c.DeleteConfig(ctx, spaceIDsMap[infraProviderConfig.SpaceID], infraProviderConfig.Identifier, false) + if err != nil { + return fmt.Errorf("error while deleting infra config %s while deleting all for spaces: %w", + infraProviderConfig.Identifier, err) + } + + log.Debug().Msgf("Deleted infra config %s for space %d", infraProviderConfig.Identifier, + infraProviderConfig.SpaceID) + } + + log.Debug().Msgf("Deleted all infra providers for spaces %+v", spaceIDs) + + return nil +} diff --git a/app/services/infraprovider/delete_config.go b/app/services/infraprovider/delete_config.go index 5ddb70dc9..ca82d355f 100644 --- a/app/services/infraprovider/delete_config.go +++ b/app/services/infraprovider/delete_config.go @@ -23,8 +23,13 @@ import ( "github.com/harness/gitness/types" ) -func (c *Service) DeleteConfig(ctx context.Context, space *types.SpaceCore, identifier string) error { - err := c.tx.WithTx(ctx, func(ctx context.Context) error { +func (c *Service) DeleteConfig( + ctx context.Context, + space *types.SpaceCore, + identifier string, + useTransaction bool, +) error { + deleteFunc := func(ctx context.Context) error { infraProviderConfig, err := c.Find(ctx, space, identifier) if err != nil { return fmt.Errorf("could not find infra provider config %s to delete: %w", identifier, err) @@ -34,9 +39,9 @@ func (c *Service) DeleteConfig(ctx context.Context, space *types.SpaceCore, iden "not allowed until all resources are deleted.", len(infraProviderConfig.Resources)) } return c.infraProviderConfigStore.Delete(ctx, infraProviderConfig.ID) - }) - if err != nil { - return err } - return nil + if useTransaction { + return c.tx.WithTx(ctx, deleteFunc) + } + return deleteFunc(ctx) } diff --git a/app/services/infraprovider/delete_resource.go b/app/services/infraprovider/delete_resource.go index 0e9cdd416..d789218f1 100644 --- a/app/services/infraprovider/delete_resource.go +++ b/app/services/infraprovider/delete_resource.go @@ -27,8 +27,10 @@ func (c *Service) DeleteResource( spaceID int64, infraProviderConfigIdentifier string, identifier string, + useTransaction bool, ) error { - err := c.tx.WithTx(ctx, func(ctx context.Context) error { + var err error + deleteFunc := func(ctx context.Context) error { infraProviderConfig, err := c.infraProviderConfigStore.FindByIdentifier(ctx, spaceID, infraProviderConfigIdentifier) if err != nil { @@ -56,7 +58,13 @@ func (c *Service) DeleteResource( } return c.infraProviderResourceStore.Delete(ctx, infraProviderResource.ID) - }) + } + + if useTransaction { + err = c.tx.WithTx(ctx, deleteFunc) + } else { + err = deleteFunc(ctx) + } if err != nil { return fmt.Errorf("failed to complete txn for deleting the infra resource %s: %w", identifier, err) diff --git a/app/services/infraprovider/list.go b/app/services/infraprovider/list.go index ae63bb6b7..3e063aeeb 100644 --- a/app/services/infraprovider/list.go +++ b/app/services/infraprovider/list.go @@ -23,16 +23,18 @@ import ( func (c *Service) List( ctx context.Context, - space *types.SpaceCore, + filter *types.InfraProviderConfigFilter, ) ([]*types.InfraProviderConfig, error) { - infraProviderConfigs, err := c.infraProviderConfigStore.List(ctx, &types.InfraProviderConfigFilter{ - SpaceID: space.ID, - }) + infraProviderConfigs, err := c.infraProviderConfigStore.List(ctx, filter) if err != nil { return nil, fmt.Errorf("failed to list infraprovider configs: %w", err) } for _, infraProviderConfig := range infraProviderConfigs { + space, err := c.spaceFinder.FindByID(ctx, infraProviderConfig.SpaceID) + if err != nil { + return nil, fmt.Errorf("failed to list infraprovider configs: %w", err) + } err = c.populateDetails(ctx, space.Path, infraProviderConfig) if err != nil { return nil, err diff --git a/app/services/wire.go b/app/services/wire.go index a246ca92d..802234211 100644 --- a/app/services/wire.go +++ b/app/services/wire.go @@ -17,6 +17,7 @@ package services import ( "github.com/harness/gitness/app/services/cleanup" "github.com/harness/gitness/app/services/gitspace" + "github.com/harness/gitness/app/services/gitspacedeleteevent" "github.com/harness/gitness/app/services/gitspaceevent" "github.com/harness/gitness/app/services/gitspaceinfraevent" "github.com/harness/gitness/app/services/gitspaceoperationsevent" @@ -63,10 +64,12 @@ type GitspaceServices struct { gitspace *gitspace.Service gitspaceInfraEventSvc *gitspaceinfraevent.Service gitspaceOperationsEventSvc *gitspaceoperationsevent.Service + gitspaceDeleteEventSvc *gitspacedeleteevent.Service } func ProvideGitspaceServices( gitspaceEventSvc *gitspaceevent.Service, + gitspaceDeleteEventSvc *gitspacedeleteevent.Service, infraProviderSvc *infraprovider.Service, gitspaceSvc *gitspace.Service, gitspaceInfraEventSvc *gitspaceinfraevent.Service, @@ -78,6 +81,7 @@ func ProvideGitspaceServices( gitspace: gitspaceSvc, gitspaceInfraEventSvc: gitspaceInfraEventSvc, gitspaceOperationsEventSvc: gitspaceOperationsEventSvc, + gitspaceDeleteEventSvc: gitspaceDeleteEventSvc, } } diff --git a/app/store/database.go b/app/store/database.go index 78a572ced..7766c4043 100644 --- a/app/store/database.go +++ b/app/store/database.go @@ -767,7 +767,7 @@ type ( InfraProviderConfigStore interface { // Find returns a infra provider config given a ID from the datastore. - Find(ctx context.Context, id int64) (*types.InfraProviderConfig, error) + Find(ctx context.Context, id int64, includeDeleted bool) (*types.InfraProviderConfig, error) // FindByIdentifier returns a infra provider config with a given UID in a space FindByIdentifier(ctx context.Context, spaceID int64, identifier string) (*types.InfraProviderConfig, error) diff --git a/app/store/database/infra_provider_config.go b/app/store/database/infra_provider_config.go index 2778a1f01..d258c7277 100644 --- a/app/store/database/infra_provider_config.go +++ b/app/store/database/infra_provider_config.go @@ -25,6 +25,7 @@ import ( "github.com/harness/gitness/types" "github.com/harness/gitness/types/enum" + "github.com/Masterminds/squirrel" "github.com/guregu/null" "github.com/jmoiron/sqlx" "github.com/pkg/errors" @@ -95,12 +96,20 @@ func (i infraProviderConfigStore) Update(ctx context.Context, infraProviderConfi return nil } -func (i infraProviderConfigStore) Find(ctx context.Context, id int64) (*types.InfraProviderConfig, error) { +func (i infraProviderConfigStore) Find( + ctx context.Context, + id int64, + includeDeleted bool, +) (*types.InfraProviderConfig, error) { stmt := database.Builder. Select(infraProviderConfigSelectColumns). From(infraProviderConfigTable). - Where("ipconf_is_deleted = false"). Where(infraProviderConfigIDColumn+" = ?", id) //nolint:goconst + + if !includeDeleted { + stmt = stmt.Where("ipconf_is_deleted = false") + } + sql, args, err := stmt.ToSql() if err != nil { return nil, errors.Wrap(err, "Failed to convert squirrel builder to sql") @@ -122,8 +131,8 @@ func (i infraProviderConfigStore) List( From(infraProviderConfigTable). Where("ipconf_is_deleted = false") - if filter != nil && filter.SpaceID > 0 { - stmt = stmt.Where("ipconf_space_id = ?", filter.SpaceID) + if filter != nil && len(filter.SpaceIDs) > 0 { + stmt = stmt.Where(squirrel.Eq{"ipconf_space_id": filter.SpaceIDs}) } if filter != nil && filter.Type != "" { diff --git a/cli/operations/server/config.go b/cli/operations/server/config.go index d113aa511..dbf7d2922 100644 --- a/cli/operations/server/config.go +++ b/cli/operations/server/config.go @@ -27,6 +27,7 @@ import ( "github.com/harness/gitness/app/gitspace/orchestrator/ide" "github.com/harness/gitness/app/services/cleanup" "github.com/harness/gitness/app/services/codeowners" + "github.com/harness/gitness/app/services/gitspacedeleteevent" "github.com/harness/gitness/app/services/gitspaceevent" "github.com/harness/gitness/app/services/keywordsearch" "github.com/harness/gitness/app/services/notification" @@ -480,3 +481,13 @@ func ProvideGitspaceEventConfig(config *types.Config) *gitspaceevent.Config { TimeoutInMins: config.Gitspace.Events.TimeoutInMins, } } + +// ProvideGitspaceDeleteEventConfig loads the gitspace delete event service config from the main config. +func ProvideGitspaceDeleteEventConfig(config *types.Config) *gitspacedeleteevent.Config { + return &gitspacedeleteevent.Config{ + EventReaderName: config.InstanceID, + Concurrency: config.Gitspace.Events.Concurrency, + MaxRetries: config.Gitspace.Events.MaxRetries, + TimeoutInMins: config.Gitspace.Events.TimeoutInMins, + } +} diff --git a/cmd/gitness/wire.go b/cmd/gitness/wire.go index 7ac6dab74..9cad69740 100644 --- a/cmd/gitness/wire.go +++ b/cmd/gitness/wire.go @@ -55,6 +55,7 @@ import ( connectorservice "github.com/harness/gitness/app/connector" gitevents "github.com/harness/gitness/app/events/git" gitspaceevents "github.com/harness/gitness/app/events/gitspace" + gitspacedeleteevents "github.com/harness/gitness/app/events/gitspacedelete" gitspaceinfraevents "github.com/harness/gitness/app/events/gitspaceinfra" gitspaceoperationsevents "github.com/harness/gitness/app/events/gitspaceoperations" pipelineevents "github.com/harness/gitness/app/events/pipeline" @@ -85,6 +86,7 @@ import ( "github.com/harness/gitness/app/services/codecomments" "github.com/harness/gitness/app/services/codeowners" "github.com/harness/gitness/app/services/exporter" + gitspacedeleteeventservice "github.com/harness/gitness/app/services/gitspacedeleteevent" "github.com/harness/gitness/app/services/gitspaceevent" "github.com/harness/gitness/app/services/gitspaceservice" "github.com/harness/gitness/app/services/importer" @@ -266,6 +268,7 @@ func initSystem(ctx context.Context, config *types.Config) (*cliserver.System, e cliserver.ProvideIDEVSCodeWebConfig, cliserver.ProvideDockerConfig, cliserver.ProvideGitspaceEventConfig, + cliserver.ProvideGitspaceDeleteEventConfig, logutil.WireSet, cliserver.ProvideGitspaceOrchestratorConfig, ide.WireSet, @@ -283,6 +286,8 @@ func initSystem(ctx context.Context, config *types.Config) (*cliserver.System, e usage.WireSet, registryevents.WireSet, registrywebhooks.WireSet, + gitspacedeleteevents.WireSet, + gitspacedeleteeventservice.WireSet, ) return &cliserver.System{}, nil } diff --git a/cmd/gitness/wire_gen.go b/cmd/gitness/wire_gen.go index edf015c79..90ab93bd4 100644 --- a/cmd/gitness/wire_gen.go +++ b/cmd/gitness/wire_gen.go @@ -42,12 +42,13 @@ import ( "github.com/harness/gitness/app/auth/authz" "github.com/harness/gitness/app/bootstrap" "github.com/harness/gitness/app/connector" - events8 "github.com/harness/gitness/app/events/git" + events9 "github.com/harness/gitness/app/events/git" events3 "github.com/harness/gitness/app/events/gitspace" + events6 "github.com/harness/gitness/app/events/gitspacedelete" events4 "github.com/harness/gitness/app/events/gitspaceinfra" events5 "github.com/harness/gitness/app/events/gitspaceoperations" - events6 "github.com/harness/gitness/app/events/pipeline" - events7 "github.com/harness/gitness/app/events/pullreq" + events7 "github.com/harness/gitness/app/events/pipeline" + events8 "github.com/harness/gitness/app/events/pullreq" events2 "github.com/harness/gitness/app/events/repo" "github.com/harness/gitness/app/gitspace/infrastructure" "github.com/harness/gitness/app/gitspace/logutil" @@ -75,6 +76,7 @@ import ( "github.com/harness/gitness/app/services/codeowners" "github.com/harness/gitness/app/services/exporter" "github.com/harness/gitness/app/services/gitspace" + "github.com/harness/gitness/app/services/gitspacedeleteevent" "github.com/harness/gitness/app/services/gitspaceevent" "github.com/harness/gitness/app/services/gitspaceinfraevent" "github.com/harness/gitness/app/services/gitspaceoperationsevent" @@ -123,7 +125,7 @@ import ( "github.com/harness/gitness/pubsub" api2 "github.com/harness/gitness/registry/app/api" "github.com/harness/gitness/registry/app/api/router" - events9 "github.com/harness/gitness/registry/app/events" + events10 "github.com/harness/gitness/registry/app/events" "github.com/harness/gitness/registry/app/pkg" "github.com/harness/gitness/registry/app/pkg/docker" "github.com/harness/gitness/registry/app/pkg/filemanager" @@ -351,14 +353,18 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro passwordResolver := secret.ProvidePasswordResolver() resolverFactory := secret.ProvideResolverFactory(passwordResolver) orchestratorOrchestrator := orchestrator.ProvideOrchestrator(scmSCM, platformConnector, infraProvisioner, containerFactory, eventsReporter, orchestratorConfig, ideFactory, resolverFactory, gitspaceInstanceStore) - gitspaceService := gitspace.ProvideGitspace(transactor, gitspaceConfigStore, gitspaceInstanceStore, eventsReporter, gitspaceEventStore, spaceFinder, infraproviderService, orchestratorOrchestrator, scmSCM, config) - usageMetricStore := database.ProvideUsageMetricStore(db) - spaceController := space.ProvideController(config, transactor, provider, streamer, spaceIdentifier, authorizer, spacePathStore, pipelineStore, secretStore, connectorStore, templateStore, spaceStore, repoStore, principalStore, repoController, membershipStore, listService, spaceFinder, repository, exporterRepository, resourceLimiter, publicaccessService, auditService, gitspaceService, labelService, instrumentService, executionStore, rulesService, usageMetricStore, repoIdentifier) reporter4, err := events6.ProvideReporter(eventsSystem) if err != nil { return nil, err } - pipelineController := pipeline.ProvideController(triggerStore, authorizer, pipelineStore, reporter4, repoFinder) + gitspaceService := gitspace.ProvideGitspace(transactor, gitspaceConfigStore, gitspaceInstanceStore, eventsReporter, gitspaceEventStore, spaceFinder, infraproviderService, orchestratorOrchestrator, scmSCM, config, reporter4) + usageMetricStore := database.ProvideUsageMetricStore(db) + spaceController := space.ProvideController(config, transactor, provider, streamer, spaceIdentifier, authorizer, spacePathStore, pipelineStore, secretStore, connectorStore, templateStore, spaceStore, repoStore, principalStore, repoController, membershipStore, listService, spaceFinder, repository, exporterRepository, resourceLimiter, publicaccessService, auditService, gitspaceService, labelService, instrumentService, executionStore, rulesService, usageMetricStore, repoIdentifier, infraproviderService) + reporter5, err := events7.ProvideReporter(eventsSystem) + if err != nil { + return nil, err + } + pipelineController := pipeline.ProvideController(triggerStore, authorizer, pipelineStore, reporter5, repoFinder) secretController := secret2.ProvideController(encrypter, secretStore, authorizer, spaceFinder) triggerController := trigger.ProvideController(authorizer, triggerStore, pipelineStore, repoFinder) scmService := connector.ProvideSCMConnectorHandler(secretStore) @@ -372,25 +378,25 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro pullReqReviewerStore := database.ProvidePullReqReviewerStore(db, principalInfoCache) userGroupReviewersStore := database.ProvideUserGroupReviewerStore(db, principalInfoCache, userGroupStore) pullReqFileViewStore := database.ProvidePullReqFileViewStore(db) - reporter5, err := events7.ProvideReporter(eventsSystem) + reporter6, err := events8.ProvideReporter(eventsSystem) if err != nil { return nil, err } migrator := codecomments.ProvideMigrator(gitInterface) - readerFactory, err := events8.ProvideReaderFactory(eventsSystem) + readerFactory, err := events9.ProvideReaderFactory(eventsSystem) if err != nil { return nil, err } - eventsReaderFactory, err := events7.ProvideReaderFactory(eventsSystem) + eventsReaderFactory, err := events8.ProvideReaderFactory(eventsSystem) if err != nil { return nil, err } - pullreqService, err := pullreq.ProvideService(ctx, config, readerFactory, eventsReaderFactory, reporter5, gitInterface, repoFinder, repoStore, pullReqStore, pullReqActivityStore, principalInfoCache, codeCommentView, migrator, pullReqFileViewStore, pubSub, provider, streamer) + pullreqService, err := pullreq.ProvideService(ctx, config, readerFactory, eventsReaderFactory, reporter6, gitInterface, repoFinder, repoStore, pullReqStore, pullReqActivityStore, principalInfoCache, codeCommentView, migrator, pullReqFileViewStore, pubSub, provider, streamer) if err != nil { return nil, err } pullReq := migrate.ProvidePullReqImporter(provider, gitInterface, principalStore, spaceStore, repoStore, pullReqStore, pullReqActivityStore, labelStore, labelValueStore, pullReqLabelAssignmentStore, repoFinder, transactor, mutexManager) - pullreqController := pullreq2.ProvideController(transactor, provider, authorizer, auditService, pullReqStore, pullReqActivityStore, codeCommentView, pullReqReviewStore, pullReqReviewerStore, repoStore, principalStore, userGroupStore, userGroupReviewersStore, principalInfoCache, pullReqFileViewStore, membershipStore, checkStore, gitInterface, repoFinder, reporter5, migrator, pullreqService, listService, protectionManager, streamer, codeownersService, lockerLocker, pullReq, labelService, instrumentService, searchService) + pullreqController := pullreq2.ProvideController(transactor, provider, authorizer, auditService, pullReqStore, pullReqActivityStore, codeCommentView, pullReqReviewStore, pullReqReviewerStore, repoStore, principalStore, userGroupStore, userGroupReviewersStore, principalInfoCache, pullReqFileViewStore, membershipStore, checkStore, gitInterface, repoFinder, reporter6, migrator, pullreqService, listService, protectionManager, streamer, codeownersService, lockerLocker, pullReq, labelService, instrumentService, searchService) webhookConfig := server.ProvideWebhookConfig(config) webhookStore := database.ProvideWebhookStore(db) webhookExecutionStore := database.ProvideWebhookExecutionStore(db) @@ -402,7 +408,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro } preprocessor := webhook2.ProvidePreprocessor() webhookController := webhook2.ProvideController(authorizer, spaceFinder, repoFinder, webhookService, encrypter, preprocessor) - reporter6, err := events8.ProvideReporter(eventsSystem) + reporter7, err := events9.ProvideReporter(eventsSystem) if err != nil { return nil, err } @@ -419,7 +425,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro return nil, err } lfsObjectStore := database.ProvideLFSObjectStore(db) - githookController := githook.ProvideController(authorizer, principalStore, repoStore, repoFinder, reporter6, reporter, gitInterface, pullReqStore, provider, protectionManager, clientFactory, resourceLimiter, settingsService, preReceiveExtender, updateExtender, postReceiveExtender, streamer, lfsObjectStore) + githookController := githook.ProvideController(authorizer, principalStore, repoStore, repoFinder, reporter7, reporter, gitInterface, pullReqStore, provider, protectionManager, clientFactory, resourceLimiter, settingsService, preReceiveExtender, updateExtender, postReceiveExtender, streamer, lfsObjectStore) serviceaccountController := serviceaccount.NewController(principalUID, authorizer, principalStore, spaceStore, repoStore, tokenStore) principalController := principal.ProvideController(principalStore, authorizer) usergroupController := usergroup2.ProvideController(userGroupStore, spaceStore, authorizer, searchService) @@ -464,11 +470,11 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro layerRepository := database2.ProvideLayerDao(db, mediaTypesRepository) eventReporter := docker.ProvideReporter() ociImageIndexMappingRepository := database2.ProvideOCIImageIndexMappingDao(db) - reporter7, err := events9.ProvideArtifactReporter(eventsSystem) + reporter8, err := events10.ProvideArtifactReporter(eventsSystem) if err != nil { return nil, err } - manifestService := docker.ManifestServiceProvider(registryRepository, manifestRepository, blobRepository, mediaTypesRepository, manifestReferenceRepository, tagRepository, imageRepository, artifactRepository, layerRepository, gcService, transactor, eventReporter, spaceFinder, ociImageIndexMappingRepository, reporter7, provider) + manifestService := docker.ManifestServiceProvider(registryRepository, manifestRepository, blobRepository, mediaTypesRepository, manifestReferenceRepository, tagRepository, imageRepository, artifactRepository, layerRepository, gcService, transactor, eventReporter, spaceFinder, ociImageIndexMappingRepository, reporter8, provider) registryBlobRepository := database2.ProvideRegistryBlobDao(db) bandwidthStatRepository := database2.ProvideBandwidthStatDao(db) downloadStatRepository := database2.ProvideDownloadStatDao(db) @@ -488,7 +494,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro cleanupPolicyRepository := database2.ProvideCleanupPolicyDao(db, transactor) webhooksRepository := database2.ProvideWebhookDao(db) webhooksExecutionRepository := database2.ProvideWebhookExecutionDao(db) - readerFactory2, err := events9.ProvideReaderFactory(eventsSystem) + readerFactory2, err := events10.ProvideReaderFactory(eventsSystem) if err != nil { return nil, err } @@ -520,7 +526,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro serverServer := server2.ProvideServer(config, routerRouter) publickeyService := publickey.ProvidePublicKey(publicKeyStore, principalInfoCache) sshServer := ssh.ProvideServer(config, publickeyService, repoController, lfsController) - executionManager := manager.ProvideExecutionManager(config, executionStore, pipelineStore, provider, streamer, fileService, converterService, logStore, logStream, checkStore, repoStore, schedulerScheduler, secretStore, stageStore, stepStore, principalStore, publicaccessService, reporter4) + executionManager := manager.ProvideExecutionManager(config, executionStore, pipelineStore, provider, streamer, fileService, converterService, logStore, logStream, checkStore, repoStore, schedulerScheduler, secretStore, stageStore, stepStore, principalStore, publicaccessService, reporter5) client := manager.ProvideExecutionClient(executionManager, provider, config) resolverManager := resolver.ProvideResolver(config, pluginStore, templateStore, executionStore, repoStore) runtimeRunner, err := runner.ProvideExecutionRunner(config, client, resolverManager) @@ -575,23 +581,32 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro if err != nil { return nil, err } - readerFactory5, err := events4.ProvideReaderFactory(eventsSystem) + gitspacedeleteeventConfig := server.ProvideGitspaceDeleteEventConfig(config) + readerFactory5, err := events6.ProvideReaderFactory(eventsSystem) if err != nil { return nil, err } - gitspaceinfraeventService, err := gitspaceinfraevent.ProvideService(ctx, gitspaceeventConfig, readerFactory5, orchestratorOrchestrator, gitspaceService, eventsReporter) + gitspacedeleteeventService, err := gitspacedeleteevent.ProvideService(ctx, gitspacedeleteeventConfig, readerFactory5, gitspaceService) if err != nil { return nil, err } - readerFactory6, err := events5.ProvideReaderFactory(eventsSystem) + readerFactory6, err := events4.ProvideReaderFactory(eventsSystem) if err != nil { return nil, err } - gitspaceoperationseventService, err := gitspaceoperationsevent.ProvideService(ctx, gitspaceeventConfig, readerFactory6, orchestratorOrchestrator, gitspaceService, eventsReporter) + gitspaceinfraeventService, err := gitspaceinfraevent.ProvideService(ctx, gitspaceeventConfig, readerFactory6, orchestratorOrchestrator, gitspaceService, eventsReporter) if err != nil { return nil, err } - gitspaceServices := services.ProvideGitspaceServices(gitspaceeventService, infraproviderService, gitspaceService, gitspaceinfraeventService, gitspaceoperationseventService) + readerFactory7, err := events5.ProvideReaderFactory(eventsSystem) + if err != nil { + return nil, err + } + gitspaceoperationseventService, err := gitspaceoperationsevent.ProvideService(ctx, gitspaceeventConfig, readerFactory7, orchestratorOrchestrator, gitspaceService, eventsReporter) + if err != nil { + return nil, err + } + gitspaceServices := services.ProvideGitspaceServices(gitspaceeventService, gitspacedeleteeventService, infraproviderService, gitspaceService, gitspaceinfraeventService, gitspaceoperationseventService) consumer, err := instrument.ProvideGitConsumer(ctx, config, readerFactory, repoStore, principalInfoCache, instrumentService) if err != nil { return nil, err diff --git a/types/infra_provider.go b/types/infra_provider.go index 0e27bce10..c90bcf573 100644 --- a/types/infra_provider.go +++ b/types/infra_provider.go @@ -162,6 +162,6 @@ type InfraProviderTemplate struct { } type InfraProviderConfigFilter struct { - SpaceID int64 - Type enum.InfraProviderType + SpaceIDs []int64 + Type enum.InfraProviderType }