ci: [sync] Update from eclipse-che/che-machine-exec @ 9a4e

Signed-off-by: devstudio-release <[email protected]>

Author: devstudio-release

devspaces-machineexec/api/rest/activity.go

@@ -15,13 +15,13 @@ package rest
 import (
 	"net/http"
 
-	"github.com/eclipse-che/che-machine-exec/activity"
 	"github.com/eclipse-che/che-machine-exec/auth"
 	restUtil "github.com/eclipse-che/che-machine-exec/common/rest"
+	"github.com/eclipse-che/che-machine-exec/timeout"
 	"github.com/gin-gonic/gin"
 )
 
-func HandleActivityTick(c *gin.Context, manager activity.Manager) {
+func HandleActivityTick(c *gin.Context, manager timeout.InactivityIdleManager) {
 	if auth.IsEnabled() {
 		_, err := auth.Authenticate(c)
 		if err != nil {

devspaces-machineexec/cfg/cfg.go

@@ -34,11 +34,14 @@ var (
 	AuthenticatedUserID string
 
 	// IdleTimeout is a inactivity period after which workspace should be stopped
-	// Default -1, which mean - does not stop
+	// Default value is 30 minutes
 	IdleTimeout time.Duration
 	// StopRetryPeriod is a period after which workspace should be tried to stop if the previous try failed
-	// Defaults 10 second
+	// Default value is 10 seconds
 	StopRetryPeriod time.Duration
+	// RunTimeout is the maximum duration a workspace can be running before it is stopped
+	// Default value is -1, which means - no maximium duration
+	RunTimeout time.Duration
 
 	// UseTLS flag to enable/disable serving TLS
 	UseTLS bool
@@ -82,7 +85,32 @@ func init() {
 	}
 	flag.StringVar(&AuthenticatedUserID, "authenticated-user-id", defaultAuthenticatedUserID, "OpenShift user's ID that should has access to API. Is used only if useBearerToken is configured")
 
-	flag.DurationVar(&IdleTimeout, "idle-timeout", -1*time.Nanosecond, "IdleTimeout is a inactivity period after which workspace should be stopped. Examples: -1, 30s, 15m, 1h")
+	const defaultIdleTimeout = -1 * time.Nanosecond
+	idleTimeout := defaultIdleTimeout
+	idleTimeoutEnv := "SECONDS_OF_DW_INACTIVITY_BEFORE_IDLING"
+	idleTimeoutEnvValue, isFound := os.LookupEnv(idleTimeoutEnv)
+	if isFound && len(idleTimeoutEnvValue) > 0 {
+		if v, err := strconv.ParseInt(idleTimeoutEnvValue, 10, 32); err == nil {
+			idleTimeout = time.Duration(v) * time.Second
+		} else {
+			logrus.Errorf("Invalid value '%s' for env variable key '%s'. Value should be an integer", idleTimeoutEnvValue, idleTimeoutEnv)
+		}
+	}
+	flag.DurationVar(&IdleTimeout, "idle-timeout", idleTimeout, "IdleTimeout is a inactivity period after which workspace should be stopped. By default, IdleTimeout is set to 30m. To disable IdleTimeout, set to -1. Examples: -1, 30s, 15m, 1h")
+
+	const defaultRunTimeout = 1800 * time.Nanosecond
+	runtimeout := defaultRunTimeout
+	runTimeoutEnv := "SECONDS_OF_DW_RUN_BEFORE_IDLING"
+	runTimeoutEnvValue, isFound := os.LookupEnv(runTimeoutEnv)
+	if isFound && len(runTimeoutEnvValue) > 0 {
+		if v, err := strconv.ParseInt(runTimeoutEnvValue, 10, 32); err == nil {
+			runtimeout = time.Duration(v) * time.Second
+		} else {
+			logrus.Errorf("Invalid value '%s' for env variable key '%s'. Value should be an integer", runTimeoutEnvValue, runTimeoutEnv)
+		}
+	}
+	flag.DurationVar(&RunTimeout, "run-timeout", runtimeout, "RunTimeout is the maximum duration a workspace can run. After this period, the workspace will be stopped. Examples: -1, 30s, 15m, 1h")
+
 	flag.DurationVar(&StopRetryPeriod, "stop-retry-period", 10*time.Second, "StopRetryPeriod is a period after which workspace should be tried to stop if the previous try failed. Examples: 30s")
 
 	flag.BoolVar(&UseTLS, "use-tls", false, "Serve content via TLS")
@@ -148,6 +176,11 @@ func Print() {
 	}
 	if IdleTimeout > 0 {
 		logrus.Infof("==> Idle timeout: %s", IdleTimeout)
+	}
+	if RunTimeout > 0 {
+		logrus.Infof("==> Run timeout: %s", RunTimeout)
+	}
+	if IdleTimeout > 0 || RunTimeout > 0 {
 		logrus.Infof("==> Stop retry period: %s", StopRetryPeriod)
 	}
 }

devspaces-machineexec/main.go

@@ -15,7 +15,7 @@ package main
 import (
 	"net/http"
 
-	"github.com/eclipse-che/che-machine-exec/activity"
+	"github.com/eclipse-che/che-machine-exec/timeout"
 
 	jsonRpcApi "github.com/eclipse-che/che-machine-exec/api/jsonrpc"
 	"github.com/eclipse-che/che-machine-exec/api/rest"
@@ -30,12 +30,18 @@ func main() {
 	cfg.Parse()
 	cfg.Print()
 
-	activityManager, err := activity.New(cfg.IdleTimeout, cfg.StopRetryPeriod)
+	activityManager, err := timeout.NewInactivityIdleManager(cfg.IdleTimeout, cfg.StopRetryPeriod)
 	if err != nil {
 		logrus.Fatal("Unable to create activity manager. Cause: ", err.Error())
 		return
 	}
 
+	runtimeManager, err := timeout.NewRunIdleManager(cfg.RunTimeout, cfg.StopRetryPeriod)
+	if err != nil {
+		logrus.Fatal("Unable to create runtime manager. Cause: ", err.Error())
+		return
+	}
+
 	r := gin.Default()
 
 	if cfg.StaticPath != "" {
@@ -84,6 +90,10 @@ func main() {
 		activityManager.Start()
 	}
 
+	if runtimeManager != nil {
+		runtimeManager.Start()
+	}
+
 	if cfg.UseTLS {
 		if err := r.RunTLS(cfg.URL, "/var/serving-cert/tls.crt", "/var/serving-cert/tls.key"); err != nil {
 			logrus.Fatal("Unable to start server with TLS enabled. Cause: ", err.Error())

devspaces-machineexec/activity/manager.go renamed to devspaces-machineexec/timeout/inactivity.go

@@ -1,5 +1,5 @@
 //
-// Copyright (c) 2019-2021 Red Hat, Inc.
+// Copyright (c) 2019-2022 Red Hat, Inc.
 // This program and the accompanying materials are made
 // available under the terms of the Eclipse Public License 2.0
 // which is available at https://www.eclipse.org/legal/epl-2.0/
@@ -10,10 +10,9 @@
 //   Red Hat, Inc. - initial API and implementation
 //
 
-package activity
+package timeout
 
 import (
-	"context"
 	"errors"
 	"os"
 	"os/signal"
@@ -22,30 +21,9 @@ import (
 
 	"github.com/eclipse-che/che-machine-exec/exec"
 	"github.com/sirupsen/logrus"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
-	"k8s.io/apimachinery/pkg/runtime/schema"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/client-go/dynamic"
-	"k8s.io/client-go/rest"
 )
 
-var (
-	DevWorkspaceAPIResource = &metav1.APIResource{
-		Name:       "devworkspaces",
-		Group:      "workspace.devfile.io",
-		Version:    "v1alpha1",
-		Namespaced: true,
-	}
-
-	DevWorkspaceGroupVersion = &schema.GroupVersion{
-		Group:   "workspace.devfile.io",
-		Version: "v1alpha1",
-	}
-)
-
-type Manager interface {
+type InactivityIdleManager interface {
 	// Start starts tracking users activity and scheduling workspace stopping if there is no activity for idle timeout
 	// Should be called once
 	Start()
@@ -54,9 +32,9 @@ type Manager interface {
 	Tick()
 }
 
-func New(idleTimeout, stopRetryPeriod time.Duration) (Manager, error) {
-	if idleTimeout < 0 {
-		return &noOpManager{}, nil
+func NewInactivityIdleManager(idleTimeout, stopRetryPeriod time.Duration) (InactivityIdleManager, error) {
+	if idleTimeout <= 0 {
+		return &noOpInactivityIdleManager{}, nil
 	}
 
 	if stopRetryPeriod <= 0 {
@@ -65,7 +43,7 @@ func New(idleTimeout, stopRetryPeriod time.Duration) (Manager, error) {
 
 	namespace := exec.GetNamespace()
 	if namespace == "" {
-		return nil, errors.New("unable to evaluate the current namespace that is needed for activity manager works correctly")
+		return nil, errors.New("unable to evaluate the current namespace required for activity manager to work correctly")
 	}
 
 	workspaceName, isFound := os.LookupEnv("CHE_WORKSPACE_NAME")
@@ -76,7 +54,7 @@ func New(idleTimeout, stopRetryPeriod time.Duration) (Manager, error) {
 		}
 	}
 
-	return managerImpl{
+	return inactivityIdleManagerImpl{
 		namespace:       namespace,
 		workspaceName:   workspaceName,
 		idleTimeout:     idleTimeout,
@@ -85,14 +63,14 @@ func New(idleTimeout, stopRetryPeriod time.Duration) (Manager, error) {
 	}, nil
 }
 
-// noOpManager should be used if idle timeout is configured less 0
+// noOpInactivityIdleManager should be used if idle timeout is configured less 0
 // invocation its method does not have affect
-type noOpManager struct{}
+type noOpInactivityIdleManager struct{}
 
-func (m noOpManager) Tick()  {}
-func (m noOpManager) Start() {}
+func (m noOpInactivityIdleManager) Tick()  {}
+func (m noOpInactivityIdleManager) Start() {}
 
-type managerImpl struct {
+type inactivityIdleManagerImpl struct {
 	namespace     string
 	workspaceName string
 
@@ -102,7 +80,7 @@ type managerImpl struct {
 	activityC chan bool
 }
 
-func (m managerImpl) Tick() {
+func (m inactivityIdleManagerImpl) Tick() {
 	select {
 	case m.activityC <- true:
 	default:
@@ -111,7 +89,7 @@ func (m managerImpl) Tick() {
 	}
 }
 
-func (m managerImpl) Start() {
+func (m inactivityIdleManagerImpl) Start() {
 	logrus.Infof("Activity tracker is run and workspace will be stopped in %s if there is no activity", m.idleTimeout)
 	timer := time.NewTimer(m.idleTimeout)
 	var shutdownChan = make(chan os.Signal, 1)
@@ -121,7 +99,7 @@ func (m managerImpl) Start() {
 		for {
 			select {
 			case <-timer.C:
-				if err := m.stopWorkspace(); err != nil {
+				if err := stopWorkspace(m.namespace, m.workspaceName); err != nil {
 					timer.Reset(m.stopRetryPeriod)
 					logrus.Errorf("Failed to stop workspace. Will retry in %s. Cause: %s", m.stopRetryPeriod, err)
 				} else {
@@ -141,49 +119,3 @@ func (m managerImpl) Start() {
 		}
 	}()
 }
-
-func (m managerImpl) stopWorkspace() error {
-	c, err := newWorkspaceClientInCluster()
-	if err != nil {
-		return err
-	}
-
-	stopWorkspacePath := &unstructured.Unstructured{
-		Object: map[string]interface{}{
-			"metadata": map[string]interface{}{
-				"annotations": map[string]interface{}{
-					"controller.devfile.io/stopped-by": "inactivity",
-				},
-			},
-			"spec": map[string]interface{}{
-				"started": false,
-			},
-		},
-	}
-	jsonPath, err := stopWorkspacePath.MarshalJSON()
-	if err != nil {
-		return err
-	}
-
-	_, err = c.Resource(DevWorkspaceGroupVersion.WithResource("devworkspaces")).Namespace(m.namespace).Patch(context.TODO(), m.workspaceName, types.MergePatchType, jsonPath, v1.PatchOptions{}, "")
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func newWorkspaceClientInCluster() (dynamic.Interface, error) {
-	config, err := rest.InClusterConfig()
-	if err != nil {
-		return nil, err
-	}
-	config.APIPath = "/apis"
-	config.GroupVersion = DevWorkspaceGroupVersion
-
-	c, err := dynamic.NewForConfig(config)
-	if err != nil {
-		return nil, err
-	}
-	return c, nil
-}

devspaces-machineexec/timeout/run.go

@@ -0,0 +1,99 @@
+//
+// Copyright (c) 2022 Red Hat, Inc.
+// This program and the accompanying materials are made
+// available under the terms of the Eclipse Public License 2.0
+// which is available at https://www.eclipse.org/legal/epl-2.0/
+//
+// SPDX-License-Identifier: EPL-2.0
+//
+// Contributors:
+//   Red Hat, Inc. - initial API and implementation
+//
+
+package timeout
+
+import (
+	"errors"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/eclipse-che/che-machine-exec/exec"
+	"github.com/sirupsen/logrus"
+)
+
+type RunIdleManager interface {
+	// Start schedules workspace to stop after run timeout
+	// Should be called once
+	Start()
+}
+
+func NewRunIdleManager(runTimeout, stopRetryPeriod time.Duration) (RunIdleManager, error) {
+	if runTimeout <= 0 {
+		return &noOpRunIdleManager{}, nil
+	}
+
+	if stopRetryPeriod <= 0 {
+		return nil, errors.New("stop retry period must be greater than 0")
+	}
+
+	namespace := exec.GetNamespace()
+	if namespace == "" {
+		return nil, errors.New("unable to evaluate the current namespace required for run idle manager to work correctly")
+	}
+
+	workspaceName, isFound := os.LookupEnv("CHE_WORKSPACE_NAME")
+	if !isFound {
+		workspaceName, isFound = os.LookupEnv("DEVWORKSPACE_NAME")
+		if !isFound {
+			return nil, errors.New("CHE_WORKSPACE_NAME or DEVWORKSPACE_NAME environment variables must be set for activity manager to work correctly")
+		}
+	}
+
+	return runIdleManagerImpl{
+		namespace:       namespace,
+		workspaceName:   workspaceName,
+		runTimeout:      runTimeout,
+		stopRetryPeriod: stopRetryPeriod,
+	}, nil
+}
+
+// noOpRunIdleManager should be used if run timeout is configured less 0
+// invocation its method does not have affect
+type noOpRunIdleManager struct{}
+
+func (m noOpRunIdleManager) Start() {}
+
+type runIdleManagerImpl struct {
+	namespace     string
+	workspaceName string
+
+	runTimeout      time.Duration
+	stopRetryPeriod time.Duration
+}
+
+func (m runIdleManagerImpl) Start() {
+	logrus.Infof("Run idle manager is running. The workspace will be stopped in %s", m.runTimeout)
+	timer := time.NewTimer(m.runTimeout)
+	var shutdownChan = make(chan os.Signal, 1)
+	signal.Notify(shutdownChan, syscall.SIGTERM)
+
+	go func() {
+		for {
+			select {
+			case <-timer.C:
+				if err := stopWorkspace(m.namespace, m.workspaceName); err != nil {
+					timer.Reset(m.stopRetryPeriod)
+					logrus.Errorf("Failed to stop workspace. Will retry in %s. Cause: %s", m.stopRetryPeriod, err)
+				} else {
+					logrus.Info("Workspace has reached its run timeout. Bye")
+					return
+				}
+			case <-shutdownChan:
+				logrus.Info("Received SIGTERM: shutting down run timeout manager")
+				return
+			}
+		}
+	}()
+}