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

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.
main
Dhruv Dhruv 2025-03-18 08:00:25 +00:00 committed by Harness
parent 527b6dc58f
commit b0de915ae2
43 changed files with 772 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5
app/api/controller/infraprovider/list.go
View File

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

4
app/api/controller/space/controller.go
View File

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

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

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

25
app/api/controller/space/soft_delete.go
View File

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

3
app/api/controller/space/wire.go
View File

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

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

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

4
app/events/gitspace/events.go
View File

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

20
app/events/gitspacedelete/category.go Normal file
View File

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

65
app/events/gitspacedelete/events.go Normal file
View File

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

38
app/events/gitspacedelete/reader.go Normal file
View File

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

37
app/events/gitspacedelete/reporter.go Normal file
View File

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

35
app/events/gitspacedelete/wire.go Normal file
View File

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

10
app/gitspace/infrastructure/find.go
View File

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

35
app/services/gitspace/action_delete.go
View File

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

2
app/services/gitspace/actions.go
View File

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

58
app/services/gitspace/delete_all_for_spaces.go Normal file
View File

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

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

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

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

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

4
app/services/gitspace/wire.go
View File

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

48
app/services/gitspacedeleteevent/handler.go Normal file
View File

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

89
app/services/gitspacedeleteevent/service.go Normal file
View File

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

43
app/services/gitspacedeleteevent/wire.go Normal file
View File

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

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

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

3
app/services/gitspaceoperationsevent/handler.go
View File

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

4
app/services/infraprovider/create_config.go
View File

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

74
app/services/infraprovider/delete_all_for_spaces.go Normal file
View File

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

17
app/services/infraprovider/delete_config.go
View File

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

12
app/services/infraprovider/delete_resource.go
View File

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

10
app/services/infraprovider/list.go
View File

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

4
app/services/wire.go
View File

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

2
app/store/database.go
View File

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

17
app/store/database/infra_provider_config.go
View File

@ -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 != "" {

11
cli/operations/server/config.go
View File

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

5
cmd/gitness/wire.go
View File

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

63
cmd/gitness/wire_gen.go
View File

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

4
types/infra_provider.go
View File

@ -162,6 +162,6 @@ type InfraProviderTemplate struct {
}
type InfraProviderConfigFilter struct {
SpaceID int64
Type enum.InfraProviderType
SpaceIDs []int64
Type enum.InfraProviderType
}