feat: [CDE-336]: add methods to get inactive (#2754)

* feat: [CDE-336]: move cde action to service and store method for inactive.
* feat: [CDE-336]: update heartbeat for gitspace instance
* feat: [CDE-336]: update heartbeat for gitspace instance
* feat: [CDE-336]: update heartbeat for gitspace instance
* feat: [CDE-336]: update heartbeat for gitspace instance
* feat: [CDE-336]: update heartbeat for gitspace instance

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)
+		c.gitspaceSvc.EmitGitspaceConfigEvent(ctx, gitspaceConfig, enum.GitspaceEventTypeGitspaceActionStart)
-		err = c.startGitspaceAction(ctx, gitspaceConfig)
+		err = c.gitspaceSvc.StartGitspaceAction(ctx, gitspaceConfig)
 		return gitspaceConfig, err
 	case enum.GitspaceActionTypeStop:
-		c.emitGitspaceConfigEvent(ctx, gitspaceConfig, enum.GitspaceEventTypeGitspaceActionStop)
+		c.gitspaceSvc.EmitGitspaceConfigEvent(ctx, gitspaceConfig, enum.GitspaceEventTypeGitspaceActionStop)
-		err = c.stopGitspaceAction(ctx, gitspaceConfig, time.Now())
+		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(),
-	})
-}

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,

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

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)

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,

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(),
+	})
+}

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

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)
+		gitspaceConfigResult = gitspaceConfig
-		if err != nil && !errors.Is(err, store.ErrResourceNotFound) {
+		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
+}

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(

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

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,

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,

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/git"
-	events7 "github.com/harness/gitness/app/events/gitspace"
+	events3 "github.com/harness/gitness/app/events/gitspace"
-	events3 "github.com/harness/gitness/app/events/gitspaceinfra"
+	events4 "github.com/harness/gitness/app/events/gitspaceinfra"
-	events4 "github.com/harness/gitness/app/events/pipeline"
+	events5 "github.com/harness/gitness/app/events/pipeline"
-	events5 "github.com/harness/gitness/app/events/pullreq"
+	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)
+	dockerProvider := infraprovider.ProvideDockerProvider(dockerConfig, dockerClientFactory, reporter2)
-	secretController := secret.ProvideController(encrypter, secretStore, authorizer, spaceStore)
+	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
 	}

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
 }