Move workspace activity to CRD

Author: aledbf

components/ws-manager-api/go/crd/v1/workspace_types.go

@@ -171,6 +171,8 @@ type WorkspaceStatus struct {
 
 	// +kubebuilder:validation:Optional
 	Runtime *WorkspaceRuntimeStatus `json:"runtime,omitempty"`
+
+	LastActivity *metav1.Time `json:"lastActivity,omitempty"`
 }
 
 func (s *WorkspaceStatus) SetCondition(cond metav1.Condition) {

components/ws-manager-api/go/crd/v1/zz_generated.deepcopy.go

@@ -111,7 +111,7 @@ var _ = BeforeSuite(func() {
 	Expect(err).ToNot(HaveOccurred())
 	Expect(wsReconciler.SetupWithManager(k8sManager)).To(Succeed())
 
-	wsActivity = activity.NewWorkspaceActivity()
+	wsActivity = activity.NewWorkspaceActivity(conf.Namespace, k8sManager.GetClient())
 	timeoutReconciler, err := NewTimeoutReconciler(k8sManager.GetClient(), k8sManager.GetEventRecorderFor("workspace"), conf, wsActivity, maintenance)
 	Expect(err).ToNot(HaveOccurred())
 	Expect(timeoutReconciler.SetupWithManager(k8sManager)).To(Succeed())

components/ws-manager-mk2/controllers/suite_test.go

@@ -36,7 +36,7 @@ var _ = Describe("TimeoutController", func() {
 			// Use a fake client instead of the envtest's k8s client, such that we can add objects
 			// with custom CreationTimestamps and check timeout logic.
 			fakeClient = fake.NewClientBuilder().WithStatusSubresource(&workspacev1.Workspace{}).WithScheme(k8sClient.Scheme()).Build()
-			r, err = NewTimeoutReconciler(fakeClient, record.NewFakeRecorder(100), conf, activity.NewWorkspaceActivity(), &fakeMaintenance{enabled: false})
+			r, err = NewTimeoutReconciler(fakeClient, record.NewFakeRecorder(100), conf, activity.NewWorkspaceActivity("default", k8sClient), &fakeMaintenance{enabled: false})
 			Expect(err).ToNot(HaveOccurred())
 		})
 
@@ -207,7 +207,7 @@ var _ = Describe("TimeoutController", func() {
 		var r *TimeoutReconciler
 		BeforeEach(func() {
 			var err error
-			r, err = NewTimeoutReconciler(k8sClient, record.NewFakeRecorder(100), newTestConfig(), activity.NewWorkspaceActivity(), &fakeMaintenance{enabled: false})
+			r, err = NewTimeoutReconciler(k8sClient, record.NewFakeRecorder(100), newTestConfig(), activity.NewWorkspaceActivity("default", k8sClient), &fakeMaintenance{enabled: false})
 			Expect(err).ToNot(HaveOccurred())
 		})
 

components/ws-manager-mk2/controllers/timeout_controller_test.go

@@ -152,7 +152,7 @@ func main() {
 		os.Exit(1)
 	}
 
-	activity := activity.NewWorkspaceActivity()
+	activity := activity.NewWorkspaceActivity(cfg.Manager.Namespace, mgr.GetClient())
 
 	go func() {
 		for {

components/ws-manager-mk2/main.go

@@ -5,39 +5,101 @@
 package activity
 
 import (
-	"sync"
+	"context"
 	"time"
 
+	"k8s.io/apimachinery/pkg/api/errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/wait"
+	"k8s.io/client-go/util/retry"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/gitpod-io/gitpod/common-go/log"
 	workspacev1 "github.com/gitpod-io/gitpod/ws-manager/api/crd/v1"
 )
 
 // WorkspaceActivity is used to track the last user activity per workspace. This is
 // stored in memory instead of on the Workspace resource to limit load on the k8s API,
 // as this value will update often for each workspace.
 type WorkspaceActivity struct {
+	client    client.Client
+	namespace string
+
 	ManagerStartedAt time.Time
-	m                sync.Map
 }
 
-func NewWorkspaceActivity() *WorkspaceActivity {
+func NewWorkspaceActivity(namespace string, client client.Client) *WorkspaceActivity {
 	return &WorkspaceActivity{
 		ManagerStartedAt: time.Now().UTC(),
+		client:           client,
+		namespace:        namespace,
 	}
 }
 
+var (
+	// retryParams are custom backoff parameters used to modify a workspace.
+	// These params retry more quickly than the default retry.DefaultBackoff.
+	retryParams = wait.Backoff{
+		Steps:    10,
+		Duration: 10 * time.Millisecond,
+		Factor:   2.0,
+		Jitter:   0.2,
+	}
+)
+
 func (w *WorkspaceActivity) Store(workspaceId string, lastActivity time.Time) {
-	w.m.Store(workspaceId, &lastActivity)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	var ws workspacev1.Workspace
+	err := w.client.Get(ctx, types.NamespacedName{Namespace: w.namespace, Name: workspaceId}, &ws)
+	if err != nil {
+		log.Error(err, "cannot store workspace last activity")
+		return
+	}
+
+	lastActivityStatus := metav1.NewTime(lastActivity)
+	ws.Status.LastActivity = &lastActivityStatus
+
+	err = retry.RetryOnConflict(retryParams, func() error {
+		var ws workspacev1.Workspace
+		err := w.client.Get(ctx, types.NamespacedName{Namespace: w.namespace, Name: workspaceId}, &ws)
+		if err != nil {
+			return err
+		}
+
+		return w.client.Status().Update(ctx, &ws)
+	})
+	if err != nil {
+		log.Error(err, "cannot update workspace status")
+	}
 }
 
 func (w *WorkspaceActivity) GetLastActivity(ws *workspacev1.Workspace) *time.Time {
-	lastActivity, ok := w.m.Load(ws.Name)
-	if ok {
-		return lastActivity.(*time.Time)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	var workspace workspacev1.Workspace
+	err := w.client.Get(ctx, types.NamespacedName{
+		Namespace: ws.Namespace,
+		Name:      ws.Name,
+	}, &workspace)
+	if err != nil {
+		if !errors.IsNotFound(err) {
+			log.Error(err, "unable to fetch workspace")
+		}
+
+		return nil
+	}
+
+	if workspace.Status.LastActivity != nil {
+		return &workspace.Status.LastActivity.Time
 	}
 
 	// In case we don't have a record of the workspace's last activity, check for the FirstUserActivity condition
 	// to see if the lastActivity got lost on a manager restart.
-	if ws.IsConditionTrue(workspacev1.WorkspaceConditionFirstUserActivity) {
+	if workspace.IsConditionTrue(workspacev1.WorkspaceConditionFirstUserActivity) {
 		// Manager was restarted, consider the workspace's last activity to be the time the manager restarted.
 		return &w.ManagerStartedAt
 	}