diff --git a/app/api/controller/gitspace/action.go b/app/api/controller/gitspace/action.go index 6a7f7f603..804899a2b 100644 --- a/app/api/controller/gitspace/action.go +++ b/app/api/controller/gitspace/action.go @@ -16,7 +16,6 @@ package gitspace import ( "context" - "errors" "fmt" "strconv" "strings" @@ -24,20 +23,11 @@ import ( apiauth "github.com/harness/gitness/app/api/auth" "github.com/harness/gitness/app/auth" - events "github.com/harness/gitness/app/events/gitspace" - "github.com/harness/gitness/store" "github.com/harness/gitness/types" "github.com/harness/gitness/types/check" "github.com/harness/gitness/types/enum" - - gonanoid "github.com/matoous/go-nanoid" - "github.com/rs/zerolog/log" ) -const defaultPasswordRef = "harness_password" -const defaultMachineUser = "harness" -const gitspaceTimedOutInMintues = 10 - type ActionInput struct { Action enum.GitspaceActionType `json:"action"` Identifier string `json:"-"` @@ -94,210 +84,18 @@ func (c *Controller) Action( return nil, fmt.Errorf("usage has exceeded limit, can not start any gitspaces: %w", err) } - c.emitGitspaceConfigEvent(ctx, gitspaceConfig, enum.GitspaceEventTypeGitspaceActionStart) - err = c.startGitspaceAction(ctx, gitspaceConfig) + c.gitspaceSvc.EmitGitspaceConfigEvent(ctx, gitspaceConfig, enum.GitspaceEventTypeGitspaceActionStart) + err = c.gitspaceSvc.StartGitspaceAction(ctx, gitspaceConfig) return gitspaceConfig, err case enum.GitspaceActionTypeStop: - c.emitGitspaceConfigEvent(ctx, gitspaceConfig, enum.GitspaceEventTypeGitspaceActionStop) - err = c.stopGitspaceAction(ctx, gitspaceConfig, time.Now()) + c.gitspaceSvc.EmitGitspaceConfigEvent(ctx, gitspaceConfig, enum.GitspaceEventTypeGitspaceActionStop) + err = c.gitspaceSvc.StopGitspaceAction(ctx, gitspaceConfig, time.Now()) return gitspaceConfig, err default: return nil, fmt.Errorf("unknown action %s on gitspace : %s", string(in.Action), gitspaceConfig.Identifier) } } -func (c *Controller) startGitspaceAction( - ctx context.Context, - config *types.GitspaceConfig, -) error { - savedGitspaceInstance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, config.ID) - if err != nil && !errors.Is(err, store.ErrResourceNotFound) { - return err - } - config.GitspaceInstance = savedGitspaceInstance - err = c.gitspaceBusyOperation(ctx, config) - if err != nil { - return err - } - if savedGitspaceInstance == nil || savedGitspaceInstance.State.IsFinalStatus() { - gitspaceInstance, err := c.buildGitspaceInstance(config) - if err != nil { - return err - } - if err = c.gitspaceInstanceStore.Create(ctx, gitspaceInstance); err != nil { - return fmt.Errorf("failed to create gitspace instance for %s %w", config.Identifier, err) - } - } - newGitspaceInstance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, config.ID) - newGitspaceInstance.SpacePath = config.SpacePath - if err != nil { - return fmt.Errorf("failed to find gitspace with config ID : %s %w", config.Identifier, err) - } - config.GitspaceInstance = newGitspaceInstance - c.submitAsyncOps(ctx, config, enum.GitspaceActionTypeStart) - return nil -} - -func (c *Controller) asyncOperation( - ctxWithTimedOut context.Context, - config types.GitspaceConfig, - action enum.GitspaceActionType, - errChannel chan error, -) { - defer close(errChannel) - - var orchestrateErr error - - switch action { - case enum.GitspaceActionTypeStart: - config.GitspaceInstance.State = enum.GitspaceInstanceStateStarting - err := c.gitspaceSvc.UpdateInstance(ctxWithTimedOut, config.GitspaceInstance) - if err != nil { - log.Err(err).Msgf( - "failed to update gitspace instance during exec %q", config.GitspaceInstance.Identifier) - } - orchestrateErr = c.orchestrator.TriggerStartGitspace(ctxWithTimedOut, config) - case enum.GitspaceActionTypeStop: - config.GitspaceInstance.State = enum.GitspaceInstanceStateStopping - err := c.gitspaceSvc.UpdateInstance(ctxWithTimedOut, config.GitspaceInstance) - if err != nil { - log.Err(err).Msgf( - "failed to update gitspace instance during exec %q", config.GitspaceInstance.Identifier) - } - orchestrateErr = c.orchestrator.TriggerStopGitspace(ctxWithTimedOut, config) - } - - if orchestrateErr != nil { - errChannel <- fmt.Errorf("failed to start/stop gitspace: %s %w", config.Identifier, orchestrateErr) - } -} - -func (c *Controller) submitAsyncOps( - ctx context.Context, - config *types.GitspaceConfig, - action enum.GitspaceActionType, -) { - errChannel := make(chan error) - - submitCtx := context.WithoutCancel(ctx) - ttlExecuteContext, cancel := context.WithTimeout(submitCtx, gitspaceTimedOutInMintues*time.Minute) - - go c.asyncOperation(ttlExecuteContext, *config, action, errChannel) - - var err error - - go func() { - select { - case <-ttlExecuteContext.Done(): - if ttlExecuteContext.Err() != nil { - err = ttlExecuteContext.Err() - } - case err = <-errChannel: - } - if err != nil { - log.Err(err).Msgf("error during async execution for %s", config.GitspaceInstance.Identifier) - - config.GitspaceInstance.State = enum.GitspaceInstanceStateError - updateErr := c.gitspaceSvc.UpdateInstance(submitCtx, config.GitspaceInstance) - if updateErr != nil { - log.Err(updateErr).Msgf( - "failed to update gitspace instance during exec %q", config.GitspaceInstance.Identifier) - } - - switch action { - case enum.GitspaceActionTypeStart: - c.emitGitspaceConfigEvent(submitCtx, config, enum.GitspaceEventTypeGitspaceActionStartFailed) - case enum.GitspaceActionTypeStop: - c.emitGitspaceConfigEvent(submitCtx, config, enum.GitspaceEventTypeGitspaceActionStopFailed) - } - } - - cancel() - }() -} - -func (c *Controller) buildGitspaceInstance(config *types.GitspaceConfig) (*types.GitspaceInstance, error) { - gitspaceMachineUser := defaultMachineUser - now := time.Now().UnixMilli() - suffixUID, err := gonanoid.Generate(allowedUIDAlphabet, 6) - if err != nil { - return nil, fmt.Errorf("could not generate UID for gitspace config : %q %w", config.Identifier, err) - } - identifier := strings.ToLower(config.Identifier + "-" + suffixUID) - var gitspaceInstance = &types.GitspaceInstance{ - GitSpaceConfigID: config.ID, - Identifier: identifier, - State: enum.GitspaceInstanceStateStarting, - UserID: config.GitspaceUser.Identifier, - SpaceID: config.SpaceID, - SpacePath: config.SpacePath, - Created: now, - Updated: now, - TotalTimeUsed: 0, - } - if config.IDE == enum.IDETypeVSCodeWeb || config.IDE == enum.IDETypeVSCode { - gitspaceInstance.MachineUser = &gitspaceMachineUser - } - gitspaceInstance.AccessType = enum.GitspaceAccessTypeSSHKey - gitspaceInstance.AccessKeyRef = &config.SSHTokenIdentifier - if len(config.SSHTokenIdentifier) == 0 { - ref := strings.Clone(defaultPasswordRef) - gitspaceInstance.AccessKeyRef = &ref - gitspaceInstance.AccessType = enum.GitspaceAccessTypeUserCredentials - } - return gitspaceInstance, nil -} - -func (c *Controller) gitspaceBusyOperation( - ctx context.Context, - config *types.GitspaceConfig, -) error { - if config.GitspaceInstance == nil { - return nil - } - if config.GitspaceInstance.State.IsBusyStatus() && - time.Since(time.UnixMilli(config.GitspaceInstance.Updated)).Milliseconds() <= (gitspaceTimedOutInMintues*60*1000) { - return fmt.Errorf("gitspace start/stop is already pending for : %q", config.Identifier) - } else if config.GitspaceInstance.State.IsBusyStatus() { - config.GitspaceInstance.State = enum.GitspaceInstanceStateError - if err := c.gitspaceSvc.UpdateInstance(ctx, config.GitspaceInstance); err != nil { - return fmt.Errorf("failed to update gitspace config for %s %w", config.Identifier, err) - } - } - return nil -} - -func (c *Controller) stopGitspaceAction( - ctx context.Context, - config *types.GitspaceConfig, - now time.Time, -) error { - savedGitspaceInstance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, config.ID) - if err != nil { - return fmt.Errorf("failed to find gitspace with config ID : %s %w", config.Identifier, err) - } - if savedGitspaceInstance.State.IsFinalStatus() { - return fmt.Errorf( - "gitspace instance cannot be stopped with ID %s %w", savedGitspaceInstance.Identifier, err) - } - config.GitspaceInstance = savedGitspaceInstance - err = c.gitspaceBusyOperation(ctx, config) - if err != nil { - return err - } - - activeTimeEnded := now.UnixMilli() - config.GitspaceInstance.ActiveTimeEnded = &activeTimeEnded - config.GitspaceInstance.TotalTimeUsed = - *(config.GitspaceInstance.ActiveTimeEnded) - *(config.GitspaceInstance.ActiveTimeStarted) - config.GitspaceInstance.State = enum.GitspaceInstanceStateStopping - if err = c.gitspaceSvc.UpdateInstance(ctx, config.GitspaceInstance); err != nil { - return fmt.Errorf("failed to update gitspace config for stopping %s %w", config.Identifier, err) - } - c.submitAsyncOps(ctx, config, enum.GitspaceActionTypeStop) - return nil -} - func (c *Controller) sanitizeActionInput(in *ActionInput) error { if err := check.Identifier(in.Identifier); err != nil { return err @@ -308,17 +106,3 @@ func (c *Controller) sanitizeActionInput(in *ActionInput) error { } return nil } - -func (c *Controller) emitGitspaceConfigEvent( - ctx context.Context, - config *types.GitspaceConfig, - eventType enum.GitspaceEventType, -) { - c.eventReporter.EmitGitspaceEvent(ctx, events.GitspaceEvent, &events.GitspaceEventPayload{ - QueryKey: config.Identifier, - EntityID: config.ID, - EntityType: enum.GitspaceEntityTypeGitspaceConfig, - EventType: eventType, - Timestamp: time.Now().UnixNano(), - }) -} diff --git a/app/api/controller/gitspace/controller.go b/app/api/controller/gitspace/controller.go index d36e6600a..e60801e99 100644 --- a/app/api/controller/gitspace/controller.go +++ b/app/api/controller/gitspace/controller.go @@ -17,9 +17,7 @@ package gitspace import ( "github.com/harness/gitness/app/api/controller/limiter" "github.com/harness/gitness/app/auth/authz" - gitspaceevents "github.com/harness/gitness/app/events/gitspace" "github.com/harness/gitness/app/gitspace/logutil" - "github.com/harness/gitness/app/gitspace/orchestrator" "github.com/harness/gitness/app/gitspace/scm" "github.com/harness/gitness/app/services/gitspace" "github.com/harness/gitness/app/services/infraprovider" @@ -33,8 +31,6 @@ type Controller struct { gitspaceConfigStore store.GitspaceConfigStore gitspaceInstanceStore store.GitspaceInstanceStore spaceStore store.SpaceStore - eventReporter *gitspaceevents.Reporter - orchestrator orchestrator.Orchestrator gitspaceEventStore store.GitspaceEventStore tx dbtx.Transactor statefulLogger *logutil.StatefulLogger @@ -51,8 +47,6 @@ func NewController( gitspaceConfigStore store.GitspaceConfigStore, gitspaceInstanceStore store.GitspaceInstanceStore, spaceStore store.SpaceStore, - eventReporter *gitspaceevents.Reporter, - orchestrator orchestrator.Orchestrator, gitspaceEventStore store.GitspaceEventStore, statefulLogger *logutil.StatefulLogger, scm scm.SCM, @@ -67,8 +61,6 @@ func NewController( gitspaceConfigStore: gitspaceConfigStore, gitspaceInstanceStore: gitspaceInstanceStore, spaceStore: spaceStore, - eventReporter: eventReporter, - orchestrator: orchestrator, gitspaceEventStore: gitspaceEventStore, statefulLogger: statefulLogger, scm: scm, diff --git a/app/api/controller/gitspace/create.go b/app/api/controller/gitspace/create.go index 5cffa93cd..9e6ec2012 100644 --- a/app/api/controller/gitspace/create.go +++ b/app/api/controller/gitspace/create.go @@ -24,6 +24,7 @@ import ( apiauth "github.com/harness/gitness/app/api/auth" "github.com/harness/gitness/app/api/usererror" "github.com/harness/gitness/app/auth" + "github.com/harness/gitness/app/services/gitspace" "github.com/harness/gitness/errors" "github.com/harness/gitness/store" "github.com/harness/gitness/types" @@ -33,7 +34,6 @@ import ( gonanoid "github.com/matoous/go-nanoid" ) -const allowedUIDAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789" const defaultResourceIdentifier = "default" var ( @@ -102,7 +102,7 @@ func (c *Controller) Create( return nil, err } } - suffixUID, err := gonanoid.Generate(allowedUIDAlphabet, 6) + suffixUID, err := gonanoid.Generate(gitspace.AllowedUIDAlphabet, 6) if err != nil { return nil, fmt.Errorf("could not generate UID for gitspace config : %q %w", in.Identifier, err) } diff --git a/app/api/controller/gitspace/delete.go b/app/api/controller/gitspace/delete.go index ceb58376b..044859646 100644 --- a/app/api/controller/gitspace/delete.go +++ b/app/api/controller/gitspace/delete.go @@ -78,7 +78,7 @@ func (c *Controller) stopRunningGitspace(ctx context.Context, config types.Gitsp return } - err = c.orchestrator.TriggerDeleteGitspace(ctx, config) + err = c.gitspaceSvc.TriggerDelete(ctx, config) if err != nil { log.Ctx(ctx).Err(err).Msgf("error during triggering delete for gitspace instance %s", config.GitspaceInstance.Identifier) diff --git a/app/api/controller/gitspace/wire.go b/app/api/controller/gitspace/wire.go index 41381f373..ab80a6904 100644 --- a/app/api/controller/gitspace/wire.go +++ b/app/api/controller/gitspace/wire.go @@ -17,9 +17,7 @@ package gitspace import ( "github.com/harness/gitness/app/api/controller/limiter" "github.com/harness/gitness/app/auth/authz" - gitspaceevents "github.com/harness/gitness/app/events/gitspace" "github.com/harness/gitness/app/gitspace/logutil" - "github.com/harness/gitness/app/gitspace/orchestrator" "github.com/harness/gitness/app/gitspace/scm" "github.com/harness/gitness/app/services/gitspace" "github.com/harness/gitness/app/services/infraprovider" @@ -41,8 +39,6 @@ func ProvideController( configStore store.GitspaceConfigStore, instanceStore store.GitspaceInstanceStore, spaceStore store.SpaceStore, - reporter *gitspaceevents.Reporter, - orchestrator orchestrator.Orchestrator, eventStore store.GitspaceEventStore, statefulLogger *logutil.StatefulLogger, scm scm.SCM, @@ -57,8 +53,6 @@ func ProvideController( configStore, instanceStore, spaceStore, - reporter, - orchestrator, eventStore, statefulLogger, scm, diff --git a/app/services/gitspace/action.go b/app/services/gitspace/action.go new file mode 100644 index 000000000..40989776d --- /dev/null +++ b/app/services/gitspace/action.go @@ -0,0 +1,242 @@ +// 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" + "errors" + "fmt" + "strings" + "time" + + events "github.com/harness/gitness/app/events/gitspace" + "github.com/harness/gitness/store" + "github.com/harness/gitness/types" + "github.com/harness/gitness/types/enum" + + gonanoid "github.com/matoous/go-nanoid" + "github.com/rs/zerolog/log" +) + +const defaultPasswordRef = "harness_password" +const defaultMachineUser = "harness" +const gitspaceTimedOutInMintues = 10 +const AllowedUIDAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789" + +func (c *Service) StopGitspaceAction( + ctx context.Context, + config *types.GitspaceConfig, + now time.Time, +) error { + savedGitspaceInstance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, config.ID) + if err != nil { + return fmt.Errorf("failed to find gitspace with config ID : %s %w", config.Identifier, err) + } + if savedGitspaceInstance.State.IsFinalStatus() { + return fmt.Errorf( + "gitspace instance cannot be stopped with ID %s %w", savedGitspaceInstance.Identifier, err) + } + config.GitspaceInstance = savedGitspaceInstance + err = c.gitspaceBusyOperation(ctx, config) + if err != nil { + return err + } + + activeTimeEnded := now.UnixMilli() + config.GitspaceInstance.ActiveTimeEnded = &activeTimeEnded + config.GitspaceInstance.TotalTimeUsed = + *(config.GitspaceInstance.ActiveTimeEnded) - *(config.GitspaceInstance.ActiveTimeStarted) + config.GitspaceInstance.State = enum.GitspaceInstanceStateStopping + if err = c.UpdateInstance(ctx, config.GitspaceInstance); err != nil { + return fmt.Errorf("failed to update gitspace config for stopping %s %w", config.Identifier, err) + } + c.submitAsyncOps(ctx, config, enum.GitspaceActionTypeStop) + return nil +} + +func (c *Service) gitspaceBusyOperation( + ctx context.Context, + config *types.GitspaceConfig, +) error { + if config.GitspaceInstance == nil { + return nil + } + if config.GitspaceInstance.State.IsBusyStatus() && + time.Since(time.UnixMilli(config.GitspaceInstance.Updated)).Milliseconds() <= (gitspaceTimedOutInMintues*60*1000) { + return fmt.Errorf("gitspace start/stop is already pending for : %q", config.Identifier) + } else if config.GitspaceInstance.State.IsBusyStatus() { + config.GitspaceInstance.State = enum.GitspaceInstanceStateError + if err := c.UpdateInstance(ctx, config.GitspaceInstance); err != nil { + return fmt.Errorf("failed to update gitspace config for %s %w", config.Identifier, err) + } + } + return nil +} + +func (c *Service) submitAsyncOps( + ctx context.Context, + config *types.GitspaceConfig, + action enum.GitspaceActionType, +) { + errChannel := make(chan error) + + submitCtx := context.WithoutCancel(ctx) + ttlExecuteContext, cancel := context.WithTimeout(submitCtx, gitspaceTimedOutInMintues*time.Minute) + + go c.asyncOperation(ttlExecuteContext, *config, action, errChannel) + + var err error + + go func() { + select { + case <-ttlExecuteContext.Done(): + if ttlExecuteContext.Err() != nil { + err = ttlExecuteContext.Err() + } + case err = <-errChannel: + } + if err != nil { + log.Err(err).Msgf("error during async execution for %s", config.GitspaceInstance.Identifier) + + config.GitspaceInstance.State = enum.GitspaceInstanceStateError + updateErr := c.UpdateInstance(submitCtx, config.GitspaceInstance) + if updateErr != nil { + log.Err(updateErr).Msgf( + "failed to update gitspace instance during exec %q", config.GitspaceInstance.Identifier) + } + + switch action { + case enum.GitspaceActionTypeStart: + c.EmitGitspaceConfigEvent(submitCtx, config, enum.GitspaceEventTypeGitspaceActionStartFailed) + case enum.GitspaceActionTypeStop: + c.EmitGitspaceConfigEvent(submitCtx, config, enum.GitspaceEventTypeGitspaceActionStopFailed) + } + } + + cancel() + }() +} + +func (c *Service) StartGitspaceAction( + ctx context.Context, + config *types.GitspaceConfig, +) error { + savedGitspaceInstance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, config.ID) + if err != nil && !errors.Is(err, store.ErrResourceNotFound) { + return err + } + config.GitspaceInstance = savedGitspaceInstance + err = c.gitspaceBusyOperation(ctx, config) + if err != nil { + return err + } + if savedGitspaceInstance == nil || savedGitspaceInstance.State.IsFinalStatus() { + gitspaceInstance, err := c.buildGitspaceInstance(config) + if err != nil { + return err + } + if err = c.gitspaceInstanceStore.Create(ctx, gitspaceInstance); err != nil { + return fmt.Errorf("failed to create gitspace instance for %s %w", config.Identifier, err) + } + } + newGitspaceInstance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, config.ID) + newGitspaceInstance.SpacePath = config.SpacePath + if err != nil { + return fmt.Errorf("failed to find gitspace with config ID : %s %w", config.Identifier, err) + } + config.GitspaceInstance = newGitspaceInstance + c.submitAsyncOps(ctx, config, enum.GitspaceActionTypeStart) + return nil +} + +func (c *Service) asyncOperation( + ctxWithTimedOut context.Context, + config types.GitspaceConfig, + action enum.GitspaceActionType, + errChannel chan error, +) { + defer close(errChannel) + + var orchestrateErr error + + switch action { + case enum.GitspaceActionTypeStart: + config.GitspaceInstance.State = enum.GitspaceInstanceStateStarting + err := c.UpdateInstance(ctxWithTimedOut, config.GitspaceInstance) + if err != nil { + log.Err(err).Msgf( + "failed to update gitspace instance during exec %q", config.GitspaceInstance.Identifier) + } + orchestrateErr = c.orchestrator.TriggerStartGitspace(ctxWithTimedOut, config) + case enum.GitspaceActionTypeStop: + config.GitspaceInstance.State = enum.GitspaceInstanceStateStopping + err := c.UpdateInstance(ctxWithTimedOut, config.GitspaceInstance) + if err != nil { + log.Err(err).Msgf( + "failed to update gitspace instance during exec %q", config.GitspaceInstance.Identifier) + } + orchestrateErr = c.orchestrator.TriggerStopGitspace(ctxWithTimedOut, config) + } + + if orchestrateErr != nil { + errChannel <- fmt.Errorf("failed to start/stop gitspace: %s %w", config.Identifier, orchestrateErr) + } +} + +func (c *Service) buildGitspaceInstance(config *types.GitspaceConfig) (*types.GitspaceInstance, error) { + gitspaceMachineUser := defaultMachineUser + now := time.Now().UnixMilli() + suffixUID, err := gonanoid.Generate(AllowedUIDAlphabet, 6) + if err != nil { + return nil, fmt.Errorf("could not generate UID for gitspace config : %q %w", config.Identifier, err) + } + identifier := strings.ToLower(config.Identifier + "-" + suffixUID) + var gitspaceInstance = &types.GitspaceInstance{ + GitSpaceConfigID: config.ID, + Identifier: identifier, + State: enum.GitspaceInstanceStateStarting, + UserID: config.GitspaceUser.Identifier, + SpaceID: config.SpaceID, + SpacePath: config.SpacePath, + Created: now, + Updated: now, + TotalTimeUsed: 0, + } + if config.IDE == enum.IDETypeVSCodeWeb || config.IDE == enum.IDETypeVSCode { + gitspaceInstance.MachineUser = &gitspaceMachineUser + } + gitspaceInstance.AccessType = enum.GitspaceAccessTypeSSHKey + gitspaceInstance.AccessKeyRef = &config.SSHTokenIdentifier + if len(config.SSHTokenIdentifier) == 0 { + ref := strings.Clone(defaultPasswordRef) + gitspaceInstance.AccessKeyRef = &ref + gitspaceInstance.AccessType = enum.GitspaceAccessTypeUserCredentials + } + return gitspaceInstance, nil +} + +func (c *Service) EmitGitspaceConfigEvent( + ctx context.Context, + config *types.GitspaceConfig, + eventType enum.GitspaceEventType, +) { + c.eventReporter.EmitGitspaceEvent(ctx, events.GitspaceEvent, &events.GitspaceEventPayload{ + QueryKey: config.Identifier, + EntityID: config.ID, + EntityType: enum.GitspaceEntityTypeGitspaceConfig, + EventType: eventType, + Timestamp: time.Now().UnixNano(), + }) +} diff --git a/app/services/gitspace/delete.go b/app/services/gitspace/delete.go new file mode 100644 index 000000000..dbf93fa3d --- /dev/null +++ b/app/services/gitspace/delete.go @@ -0,0 +1,28 @@ +// 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" + + "github.com/harness/gitness/types" +) + +func (c *Service) TriggerDelete( + ctx context.Context, + config types.GitspaceConfig, +) error { + return c.orchestrator.TriggerDeleteGitspace(ctx, config) +} diff --git a/app/services/gitspace/find.go b/app/services/gitspace/find.go index 03bd66c52..d2dd947d7 100644 --- a/app/services/gitspace/find.go +++ b/app/services/gitspace/find.go @@ -40,23 +40,10 @@ func (c *Service) Find( if err != nil { return fmt.Errorf("failed to find gitspace config: %w", err) } - instance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, gitspaceConfig.ID) - if err != nil && !errors.Is(err, store.ErrResourceNotFound) { + gitspaceConfigResult = gitspaceConfig + if err = c.setInstance(ctx, gitspaceConfigResult, space); err != nil { return err } - if instance != nil { - gitspaceConfig.GitspaceInstance = instance - instance.SpacePath = gitspaceConfig.SpacePath - gitspaceStateType, err := enum.GetGitspaceStateFromInstance(instance.State, instance.Updated) - if err != nil { - return err - } - gitspaceConfig.State = gitspaceStateType - } else { - gitspaceConfig.State = enum.GitspaceStateUninitialized - } - gitspaceConfigResult = gitspaceConfig - gitspaceConfig.SpacePath = space.Path return nil }, dbtx.TxDefaultReadOnly) if txErr != nil { @@ -64,3 +51,50 @@ func (c *Service) Find( } return gitspaceConfigResult, nil } + +func (c *Service) setInstance( + ctx context.Context, + gitspaceConfig *types.GitspaceConfig, + space *types.Space, +) error { + instance, err := c.gitspaceInstanceStore.FindLatestByGitspaceConfigID(ctx, gitspaceConfig.ID) + if err != nil && !errors.Is(err, store.ErrResourceNotFound) { + return err + } + if instance != nil { + gitspaceConfig.GitspaceInstance = instance + instance.SpacePath = gitspaceConfig.SpacePath + gitspaceStateType, err := enum.GetGitspaceStateFromInstance(instance.State, instance.Updated) + if err != nil { + return err + } + gitspaceConfig.State = gitspaceStateType + } else { + gitspaceConfig.State = enum.GitspaceStateUninitialized + } + gitspaceConfig.SpacePath = space.Path + return nil +} + +func (c *Service) FindByID( + ctx context.Context, + id int64, +) (*types.GitspaceConfig, error) { + var gitspaceConfigResult *types.GitspaceConfig + txErr := c.tx.WithTx(ctx, func(ctx context.Context) error { + gitspaceConfig, err := c.gitspaceConfigStore.Find(ctx, id) + gitspaceConfigResult = gitspaceConfig + if err != nil { + return fmt.Errorf("failed to find gitspace config: %w", err) + } + space, err := c.spaceStore.Find(ctx, gitspaceConfigResult.SpaceID) + if err != nil { + return fmt.Errorf("failed to find space: %w", err) + } + return c.setInstance(ctx, gitspaceConfigResult, space) + }, dbtx.TxDefaultReadOnly) + if txErr != nil { + return nil, txErr + } + return gitspaceConfigResult, nil +} diff --git a/app/services/gitspace/gitspace.go b/app/services/gitspace/gitspace.go index 64a3b38fb..c7e347b29 100644 --- a/app/services/gitspace/gitspace.go +++ b/app/services/gitspace/gitspace.go @@ -18,6 +18,8 @@ import ( "context" "fmt" + gitspaceevents "github.com/harness/gitness/app/events/gitspace" + "github.com/harness/gitness/app/gitspace/orchestrator" "github.com/harness/gitness/app/services/infraprovider" "github.com/harness/gitness/app/store" "github.com/harness/gitness/store/database/dbtx" @@ -29,24 +31,33 @@ func NewService( tx dbtx.Transactor, gitspaceStore store.GitspaceConfigStore, gitspaceInstanceStore store.GitspaceInstanceStore, + eventReporter *gitspaceevents.Reporter, + gitspaceEventStore store.GitspaceEventStore, spaceStore store.SpaceStore, infraProviderSvc *infraprovider.Service, + orchestrator orchestrator.Orchestrator, ) *Service { return &Service{ tx: tx, gitspaceConfigStore: gitspaceStore, gitspaceInstanceStore: gitspaceInstanceStore, + eventReporter: eventReporter, + gitspaceEventStore: gitspaceEventStore, spaceStore: spaceStore, infraProviderSvc: infraProviderSvc, + orchestrator: orchestrator, } } type Service struct { gitspaceConfigStore store.GitspaceConfigStore gitspaceInstanceStore store.GitspaceInstanceStore + eventReporter *gitspaceevents.Reporter + gitspaceEventStore store.GitspaceEventStore spaceStore store.SpaceStore tx dbtx.Transactor infraProviderSvc *infraprovider.Service + orchestrator orchestrator.Orchestrator } func (c *Service) ListGitspacesForSpace( diff --git a/app/services/gitspace/wire.go b/app/services/gitspace/wire.go index c41f55854..de0539647 100644 --- a/app/services/gitspace/wire.go +++ b/app/services/gitspace/wire.go @@ -15,6 +15,8 @@ package gitspace import ( + gitspaceevents "github.com/harness/gitness/app/events/gitspace" + "github.com/harness/gitness/app/gitspace/orchestrator" "github.com/harness/gitness/app/services/infraprovider" "github.com/harness/gitness/app/store" "github.com/harness/gitness/store/database/dbtx" @@ -30,8 +32,13 @@ func ProvideGitspace( tx dbtx.Transactor, gitspaceStore store.GitspaceConfigStore, gitspaceInstanceStore store.GitspaceInstanceStore, + eventReporter *gitspaceevents.Reporter, + gitspaceEventStore store.GitspaceEventStore, spaceStore store.SpaceStore, infraProviderSvc *infraprovider.Service, + orchestrator orchestrator.Orchestrator, + ) *Service { - return NewService(tx, gitspaceStore, gitspaceInstanceStore, spaceStore, infraProviderSvc) + return NewService(tx, gitspaceStore, gitspaceInstanceStore, eventReporter, + gitspaceEventStore, spaceStore, infraProviderSvc, orchestrator) } diff --git a/app/store/database.go b/app/store/database.go index f81268850..5618df29c 100644 --- a/app/store/database.go +++ b/app/store/database.go @@ -676,6 +676,9 @@ type ( // List lists the gitspace instance present in a parent space ID in the datastore. List(ctx context.Context, filter *types.GitspaceFilter) ([]*types.GitspaceInstance, error) + // List lists the inactive gitspace instance present in the datastore + ListInactive(ctx context.Context, filter *types.GitspaceFilter) ([]int64, error) + // List lists the latest gitspace instance present for the gitspace configs in the datastore. FindAllLatestByGitspaceConfigID( ctx context.Context, diff --git a/app/store/database/gitspace_instance.go b/app/store/database/gitspace_instance.go index 24d154620..cae165dbc 100644 --- a/app/store/database/gitspace_instance.go +++ b/app/store/database/gitspace_instance.go @@ -298,6 +298,28 @@ func (g gitspaceInstanceStore) List( return g.mapToGitspaceInstances(ctx, dst) } +func (g gitspaceInstanceStore) ListInactive( + ctx context.Context, + filter *types.GitspaceFilter, +) ([]int64, error) { + stmt := database.Builder. + Select("gits_gitspace_config_id"). + From(gitspaceInstanceTable). + Where(squirrel.Lt{"gits_last_used": filter.LastUsedBefore}). + Where(squirrel.Eq{"gits_state": filter.State}). + OrderBy("gits_created ASC") + sql, args, err := stmt.ToSql() + if err != nil { + return nil, errors.Wrap(err, "Failed to convert squirrel builder to sql") + } + db := dbtx.GetAccessor(ctx, g.db) + var dst []int64 + if err := db.SelectContext(ctx, &dst, sql, args...); err != nil { + return nil, database.ProcessSQLErrorf(ctx, err, "Failed executing gitspace instance list query") + } + return dst, nil +} + func (g gitspaceInstanceStore) FindAllLatestByGitspaceConfigID( ctx context.Context, gitspaceConfigIDs []int64, diff --git a/cmd/gitness/wire_gen.go b/cmd/gitness/wire_gen.go index d47f5c8b5..ee1c4ae8c 100644 --- a/cmd/gitness/wire_gen.go +++ b/cmd/gitness/wire_gen.go @@ -27,7 +27,7 @@ import ( pullreq2 "github.com/harness/gitness/app/api/controller/pullreq" "github.com/harness/gitness/app/api/controller/repo" "github.com/harness/gitness/app/api/controller/reposettings" - "github.com/harness/gitness/app/api/controller/secret" + secret2 "github.com/harness/gitness/app/api/controller/secret" "github.com/harness/gitness/app/api/controller/service" "github.com/harness/gitness/app/api/controller/serviceaccount" "github.com/harness/gitness/app/api/controller/space" @@ -43,11 +43,11 @@ import ( "github.com/harness/gitness/app/auth/authz" "github.com/harness/gitness/app/bootstrap" "github.com/harness/gitness/app/connector" - events6 "github.com/harness/gitness/app/events/git" - events7 "github.com/harness/gitness/app/events/gitspace" - events3 "github.com/harness/gitness/app/events/gitspaceinfra" - events4 "github.com/harness/gitness/app/events/pipeline" - events5 "github.com/harness/gitness/app/events/pullreq" + events7 "github.com/harness/gitness/app/events/git" + events3 "github.com/harness/gitness/app/events/gitspace" + events4 "github.com/harness/gitness/app/events/gitspaceinfra" + events5 "github.com/harness/gitness/app/events/pipeline" + events6 "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" @@ -57,7 +57,7 @@ import ( "github.com/harness/gitness/app/gitspace/orchestrator/ide" user2 "github.com/harness/gitness/app/gitspace/orchestrator/user" "github.com/harness/gitness/app/gitspace/scm" - secret2 "github.com/harness/gitness/app/gitspace/secret" + "github.com/harness/gitness/app/gitspace/secret" "github.com/harness/gitness/app/pipeline/canceler" "github.com/harness/gitness/app/pipeline/commit" "github.com/harness/gitness/app/pipeline/converter" @@ -284,6 +284,11 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro infraProviderResourceCache := cache.ProvideInfraProviderResourceCache(infraProviderResourceView) gitspaceConfigStore := database.ProvideGitspaceConfigStore(db, principalInfoCache, infraProviderResourceCache) gitspaceInstanceStore := database.ProvideGitspaceInstanceStore(db) + eventsReporter, err := events3.ProvideReporter(eventsSystem) + if err != nil { + return nil, err + } + gitspaceEventStore := database.ProvideGitspaceEventStore(db) infraProviderResourceStore := database.ProvideInfraProviderResourceStore(db) infraProviderConfigStore := database.ProvideInfraProviderConfigStore(db) infraProviderTemplateStore := database.ProvideInfraProviderTemplateStore(db) @@ -292,21 +297,40 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro return nil, err } dockerClientFactory := infraprovider.ProvideDockerClientFactory(dockerConfig) - eventsReporter, err := events3.ProvideReporter(eventsSystem) - if err != nil { - return nil, err - } - dockerProvider := infraprovider.ProvideDockerProvider(dockerConfig, dockerClientFactory, eventsReporter) - factory := infraprovider.ProvideFactory(dockerProvider) - infraproviderService := infraprovider2.ProvideInfraProvider(transactor, infraProviderResourceStore, infraProviderConfigStore, infraProviderTemplateStore, factory, spaceStore) - gitspaceService := gitspace.ProvideGitspace(transactor, gitspaceConfigStore, gitspaceInstanceStore, spaceStore, infraproviderService) - spaceController := space.ProvideController(config, transactor, provider, streamer, spaceIdentifier, authorizer, spacePathStore, pipelineStore, secretStore, connectorStore, templateStore, spaceStore, repoStore, principalStore, repoController, membershipStore, listService, repository, exporterRepository, resourceLimiter, publicaccessService, auditService, gitspaceService, labelService, instrumentService) reporter2, err := events4.ProvideReporter(eventsSystem) if err != nil { return nil, err } - pipelineController := pipeline.ProvideController(repoStore, triggerStore, authorizer, pipelineStore, reporter2) - secretController := secret.ProvideController(encrypter, secretStore, authorizer, spaceStore) + dockerProvider := infraprovider.ProvideDockerProvider(dockerConfig, dockerClientFactory, reporter2) + factory := infraprovider.ProvideFactory(dockerProvider) + infraproviderService := infraprovider2.ProvideInfraProvider(transactor, infraProviderResourceStore, infraProviderConfigStore, infraProviderTemplateStore, factory, spaceStore) + gitnessSCM := scm.ProvideGitnessSCM(repoStore, gitInterface, tokenStore, principalStore, provider) + genericSCM := scm.ProvideGenericSCM() + scmFactory := scm.ProvideFactory(gitnessSCM, genericSCM) + scmSCM := scm.ProvideSCM(scmFactory) + infraProvisionedStore := database.ProvideInfraProvisionedStore(db) + infrastructureConfig := server.ProvideGitspaceInfraProvisionerConfig(config) + infraProvisioner := infrastructure.ProvideInfraProvisionerService(infraProviderConfigStore, infraProviderResourceStore, factory, infraProviderTemplateStore, infraProvisionedStore, infrastructureConfig) + statefulLogger := logutil.ProvideStatefulLogger(logStream) + gitService := git2.ProvideGitServiceImpl() + userService := user2.ProvideUserServiceImpl() + containerOrchestrator := container.ProvideEmbeddedDockerOrchestrator(dockerClientFactory, statefulLogger, gitService, userService) + orchestratorConfig := server.ProvideGitspaceOrchestratorConfig(config) + vsCodeConfig := server.ProvideIDEVSCodeConfig(config) + vsCode := ide.ProvideVSCodeService(vsCodeConfig) + vsCodeWebConfig := server.ProvideIDEVSCodeWebConfig(config) + vsCodeWeb := ide.ProvideVSCodeWebService(vsCodeWebConfig) + passwordResolver := secret.ProvidePasswordResolver() + resolverFactory := secret.ProvideResolverFactory(passwordResolver) + orchestratorOrchestrator := orchestrator.ProvideOrchestrator(scmSCM, infraProviderResourceStore, infraProvisioner, containerOrchestrator, eventsReporter, orchestratorConfig, vsCode, vsCodeWeb, resolverFactory) + gitspaceService := gitspace.ProvideGitspace(transactor, gitspaceConfigStore, gitspaceInstanceStore, eventsReporter, gitspaceEventStore, spaceStore, infraproviderService, orchestratorOrchestrator) + spaceController := space.ProvideController(config, transactor, provider, streamer, spaceIdentifier, authorizer, spacePathStore, pipelineStore, secretStore, connectorStore, templateStore, spaceStore, repoStore, principalStore, repoController, membershipStore, listService, repository, exporterRepository, resourceLimiter, publicaccessService, auditService, gitspaceService, labelService, instrumentService) + reporter3, err := events5.ProvideReporter(eventsSystem) + if err != nil { + return nil, err + } + pipelineController := pipeline.ProvideController(repoStore, triggerStore, authorizer, pipelineStore, reporter3) + secretController := secret2.ProvideController(encrypter, secretStore, authorizer, spaceStore) triggerController := trigger.ProvideController(authorizer, triggerStore, pipelineStore, repoStore) scmService := connector.ProvideSCMConnectorHandler(secretStore) connectorService := connector.ProvideConnectorHandler(secretStore, scmService) @@ -319,25 +343,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) - reporter3, err := events5.ProvideReporter(eventsSystem) + reporter4, err := events6.ProvideReporter(eventsSystem) if err != nil { return nil, err } migrator := codecomments.ProvideMigrator(gitInterface) - readerFactory, err := events6.ProvideReaderFactory(eventsSystem) + readerFactory, err := events7.ProvideReaderFactory(eventsSystem) if err != nil { return nil, err } - eventsReaderFactory, err := events5.ProvideReaderFactory(eventsSystem) + eventsReaderFactory, err := events6.ProvideReaderFactory(eventsSystem) if err != nil { return nil, err } - pullreqService, err := pullreq.ProvideService(ctx, config, readerFactory, eventsReaderFactory, reporter3, gitInterface, repoGitInfoCache, repoStore, pullReqStore, pullReqActivityStore, principalInfoCache, codeCommentView, migrator, pullReqFileViewStore, pubSub, provider, streamer) + pullreqService, err := pullreq.ProvideService(ctx, config, readerFactory, eventsReaderFactory, reporter4, gitInterface, repoGitInfoCache, repoStore, pullReqStore, pullReqActivityStore, principalInfoCache, codeCommentView, migrator, pullReqFileViewStore, pubSub, provider, streamer) if err != nil { return nil, err } pullReq := migrate.ProvidePullReqImporter(provider, gitInterface, principalStore, repoStore, pullReqStore, pullReqActivityStore, transactor) - pullreqController := pullreq2.ProvideController(transactor, provider, authorizer, pullReqStore, pullReqActivityStore, codeCommentView, pullReqReviewStore, pullReqReviewerStore, repoStore, principalStore, userGroupStore, userGroupReviewersStore, principalInfoCache, pullReqFileViewStore, membershipStore, checkStore, gitInterface, reporter3, migrator, pullreqService, listService, protectionManager, streamer, codeownersService, lockerLocker, pullReq, labelService, instrumentService, searchService) + pullreqController := pullreq2.ProvideController(transactor, provider, authorizer, pullReqStore, pullReqActivityStore, codeCommentView, pullReqReviewStore, pullReqReviewerStore, repoStore, principalStore, userGroupStore, userGroupReviewersStore, principalInfoCache, pullReqFileViewStore, membershipStore, checkStore, gitInterface, reporter4, migrator, pullreqService, listService, protectionManager, streamer, codeownersService, lockerLocker, pullReq, labelService, instrumentService, searchService) webhookConfig := server.ProvideWebhookConfig(config) webhookStore := database.ProvideWebhookStore(db) webhookExecutionStore := database.ProvideWebhookExecutionStore(db) @@ -346,7 +370,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro return nil, err } webhookController := webhook2.ProvideController(webhookConfig, authorizer, webhookStore, webhookExecutionStore, repoStore, webhookService, encrypter) - reporter4, err := events6.ProvideReporter(eventsSystem) + reporter5, err := events7.ProvideReporter(eventsSystem) if err != nil { return nil, err } @@ -362,7 +386,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro if err != nil { return nil, err } - githookController := githook.ProvideController(authorizer, principalStore, repoStore, reporter4, reporter, gitInterface, pullReqStore, provider, protectionManager, clientFactory, resourceLimiter, settingsService, preReceiveExtender, updateExtender, postReceiveExtender) + githookController := githook.ProvideController(authorizer, principalStore, repoStore, reporter5, reporter, gitInterface, pullReqStore, provider, protectionManager, clientFactory, resourceLimiter, settingsService, preReceiveExtender, updateExtender, postReceiveExtender) serviceaccountController := serviceaccount.NewController(principalUID, authorizer, principalStore, spaceStore, repoStore, tokenStore) principalController := principal.ProvideController(principalStore, authorizer) usergroupController := usergroup2.ProvideController(userGroupStore, spaceStore, authorizer, searchService) @@ -381,32 +405,8 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro searcher := keywordsearch.ProvideSearcher(localIndexSearcher) keywordsearchController := keywordsearch2.ProvideController(authorizer, searcher, repoController, spaceController) infraproviderController := infraprovider3.ProvideController(authorizer, spaceStore, infraproviderService) - reporter5, err := events7.ProvideReporter(eventsSystem) - if err != nil { - return nil, err - } - gitnessSCM := scm.ProvideGitnessSCM(repoStore, gitInterface, tokenStore, principalStore, provider) - genericSCM := scm.ProvideGenericSCM() - scmFactory := scm.ProvideFactory(gitnessSCM, genericSCM) - scmSCM := scm.ProvideSCM(scmFactory) - infraProvisionedStore := database.ProvideInfraProvisionedStore(db) - infrastructureConfig := server.ProvideGitspaceInfraProvisionerConfig(config) - infraProvisioner := infrastructure.ProvideInfraProvisionerService(infraProviderConfigStore, infraProviderResourceStore, factory, infraProviderTemplateStore, infraProvisionedStore, infrastructureConfig) - statefulLogger := logutil.ProvideStatefulLogger(logStream) - gitService := git2.ProvideGitServiceImpl() - userService := user2.ProvideUserServiceImpl() - containerOrchestrator := container.ProvideEmbeddedDockerOrchestrator(dockerClientFactory, statefulLogger, gitService, userService) - orchestratorConfig := server.ProvideGitspaceOrchestratorConfig(config) - vsCodeConfig := server.ProvideIDEVSCodeConfig(config) - vsCode := ide.ProvideVSCodeService(vsCodeConfig) - vsCodeWebConfig := server.ProvideIDEVSCodeWebConfig(config) - vsCodeWeb := ide.ProvideVSCodeWebService(vsCodeWebConfig) - passwordResolver := secret2.ProvidePasswordResolver() - resolverFactory := secret2.ProvideResolverFactory(passwordResolver) - orchestratorOrchestrator := orchestrator.ProvideOrchestrator(scmSCM, infraProviderResourceStore, infraProvisioner, containerOrchestrator, reporter5, orchestratorConfig, vsCode, vsCodeWeb, resolverFactory) - gitspaceEventStore := database.ProvideGitspaceEventStore(db) limiterGitspace := limiter.ProvideGitspaceLimiter() - gitspaceController := gitspace2.ProvideController(transactor, authorizer, infraproviderService, gitspaceConfigStore, gitspaceInstanceStore, spaceStore, reporter5, orchestratorOrchestrator, gitspaceEventStore, statefulLogger, scmSCM, repoStore, gitspaceService, limiterGitspace) + gitspaceController := gitspace2.ProvideController(transactor, authorizer, infraproviderService, gitspaceConfigStore, gitspaceInstanceStore, spaceStore, gitspaceEventStore, statefulLogger, scmSCM, repoStore, gitspaceService, limiterGitspace) rule := migrate.ProvideRuleImporter(ruleStore, transactor, principalStore) migrateWebhook := migrate.ProvideWebhookImporter(webhookConfig, transactor, webhookStore) migrateController := migrate2.ProvideController(authorizer, publicaccessService, gitInterface, provider, pullReq, rule, migrateWebhook, resourceLimiter, auditService, repoIdentifier, transactor, spaceStore, repoStore) @@ -464,7 +464,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) - executionManager := manager.ProvideExecutionManager(config, executionStore, pipelineStore, provider, streamer, fileService, converterService, logStore, logStream, checkStore, repoStore, schedulerScheduler, secretStore, stageStore, stepStore, principalStore, publicaccessService, reporter2) + executionManager := manager.ProvideExecutionManager(config, executionStore, pipelineStore, provider, streamer, fileService, converterService, logStore, logStream, checkStore, repoStore, schedulerScheduler, secretStore, stageStore, stepStore, principalStore, publicaccessService, reporter3) client := manager.ProvideExecutionClient(executionManager, provider, config) resolverManager := resolver.ProvideResolver(config, pluginStore, templateStore, executionStore, repoStore) runtimeRunner, err := runner.ProvideExecutionRunner(config, client, resolverManager) @@ -512,7 +512,7 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro return nil, err } gitspaceeventConfig := server.ProvideGitspaceEventConfig(config) - readerFactory3, err := events7.ProvideReaderFactory(eventsSystem) + readerFactory3, err := events3.ProvideReaderFactory(eventsSystem) if err != nil { return nil, err } @@ -520,11 +520,11 @@ func initSystem(ctx context.Context, config *types.Config) (*server.System, erro if err != nil { return nil, err } - readerFactory4, err := events3.ProvideReaderFactory(eventsSystem) + readerFactory4, err := events4.ProvideReaderFactory(eventsSystem) if err != nil { return nil, err } - gitspaceinfraeventService, err := gitspaceinfraevent.ProvideService(ctx, gitspaceeventConfig, readerFactory4, orchestratorOrchestrator, gitspaceService, reporter5) + gitspaceinfraeventService, err := gitspaceinfraevent.ProvideService(ctx, gitspaceeventConfig, readerFactory4, orchestratorOrchestrator, gitspaceService, eventsReporter) if err != nil { return nil, err } diff --git a/types/gitspace.go b/types/gitspace.go index 1bf0abc9e..da210ce61 100644 --- a/types/gitspace.go +++ b/types/gitspace.go @@ -81,6 +81,8 @@ type GitspaceInstance struct { type GitspaceFilter struct { QueryFilter ListQueryFilter UserID string + LastUsedBefore int64 + State []enum.GitspaceInstanceStateType SpaceIDs []int64 IncludeDeleted bool }