[server] Move WorkspaceDeleteionService into WorkspaceGC

Author: geropl

components/server/src/container-module.ts

@@ -118,7 +118,6 @@ import { ReferrerPrefixParser } from "./workspace/referrer-prefix-context-parser
 import { SnapshotContextParser } from "./workspace/snapshot-context-parser";
 import { SnapshotService } from "./workspace/snapshot-service";
 import { WorkspaceClusterImagebuilderClientProvider } from "./workspace/workspace-cluster-imagebuilder-client-provider";
-import { WorkspaceDeletionService } from "./workspace/workspace-deletion-service";
 import { WorkspaceDownloadService } from "./workspace/workspace-download-service";
 import { WorkspaceFactory } from "./workspace/workspace-factory";
 import { WorkspaceStarter } from "./workspace/workspace-starter";
@@ -162,7 +161,6 @@ export const productionContainerModule = new ContainerModule(
         bind(SnapshotService).toSelf().inSingletonScope();
         bind(WorkspaceService).toSelf().inSingletonScope();
         bind(WorkspaceFactory).toSelf().inSingletonScope();
-        bind(WorkspaceDeletionService).toSelf().inSingletonScope();
         bind(WorkspaceStarter).toSelf().inSingletonScope();
         bind(ImageSourceProvider).toSelf().inSingletonScope();
 

components/server/src/jobs/workspace-gc.ts

@@ -6,13 +6,19 @@
 
 import { injectable, inject, postConstruct } from "inversify";
 import { log } from "@gitpod/gitpod-protocol/lib/util/logging";
-import { WorkspaceDeletionService } from "../workspace/workspace-deletion-service";
 import * as opentracing from "opentracing";
-import { TracedWorkspaceDB, DBWithTracing, WorkspaceDB } from "@gitpod/gitpod-db/lib";
+import {
+    TracedWorkspaceDB,
+    DBWithTracing,
+    WorkspaceDB,
+    WorkspaceAndOwner,
+    WorkspaceOwnerAndSoftDeleted,
+} from "@gitpod/gitpod-db/lib";
 import { TraceContext } from "@gitpod/gitpod-protocol/lib/util/tracing";
 import { Config } from "../config";
 import { Job } from "./runner";
 import { WorkspaceService } from "../workspace/workspace-service";
+import { StorageClient } from "../storage/storage-client";
 
 /**
  * The WorkspaceGarbageCollector has two tasks:
@@ -21,9 +27,9 @@ import { WorkspaceService } from "../workspace/workspace-service";
  */
 @injectable()
 export class WorkspaceGarbageCollector implements Job {
-    @inject(WorkspaceDeletionService) protected readonly deletionService: WorkspaceDeletionService;
     @inject(WorkspaceService) protected readonly workspaceService: WorkspaceService;
     @inject(TracedWorkspaceDB) protected readonly workspaceDB: DBWithTracing<WorkspaceDB>;
+    @inject(StorageClient) protected readonly storageClient: StorageClient;
     @inject(Config) protected readonly config: Config;
 
     public name = "workspace-gc";
@@ -55,7 +61,7 @@ export class WorkspaceGarbageCollector implements Job {
     /**
      * Marks old, unused workspaces as softDeleted
      */
-    protected async softDeleteOldWorkspaces() {
+    private async softDeleteOldWorkspaces() {
         if (Date.now() < this.config.workspaceGarbageCollection.startDate) {
             log.info("workspace-gc: garbage collection not yet active.");
             return;
@@ -89,7 +95,7 @@ export class WorkspaceGarbageCollector implements Job {
         }
     }
 
-    protected async deleteWorkspaceContentAfterRetentionPeriod() {
+    private async deleteWorkspaceContentAfterRetentionPeriod() {
         const span = opentracing.globalTracer().startSpan("deleteWorkspaceContentAfterRetentionPeriod");
         try {
             const workspaces = await this.workspaceDB
@@ -98,9 +104,7 @@ export class WorkspaceGarbageCollector implements Job {
                     this.config.workspaceGarbageCollection.contentRetentionPeriodDays,
                     this.config.workspaceGarbageCollection.contentChunkLimit,
                 );
-            const deletes = await Promise.all(
-                workspaces.map((ws) => this.deletionService.garbageCollectWorkspace({ span }, ws)),
-            );
+            const deletes = await Promise.all(workspaces.map((ws) => this.garbageCollectWorkspace({ span }, ws)));
 
             log.info(`workspace-gc: successfully deleted the content of ${deletes.length} workspaces`);
             span.addTags({ nrOfCollectedWorkspaces: deletes.length });
@@ -115,7 +119,7 @@ export class WorkspaceGarbageCollector implements Job {
     /**
      * This method is meant to purge all traces of a Workspace and it's WorkspaceInstances from the DB
      */
-    protected async purgeWorkspacesAfterPurgeRetentionPeriod() {
+    private async purgeWorkspacesAfterPurgeRetentionPeriod() {
         const span = opentracing.globalTracer().startSpan("purgeWorkspacesAfterPurgeRetentionPeriod");
         try {
             const now = new Date();
@@ -149,9 +153,7 @@ export class WorkspaceGarbageCollector implements Job {
                     this.config.workspaceGarbageCollection.minAgePrebuildDays,
                     this.config.workspaceGarbageCollection.chunkLimit,
                 );
-            const deletes = await Promise.all(
-                workspaces.map((ws) => this.deletionService.garbageCollectPrebuild({ span }, ws)),
-            );
+            const deletes = await Promise.all(workspaces.map((ws) => this.garbageCollectPrebuild({ span }, ws)));
 
             log.info(`workspace-gc: successfully deleted ${deletes.length} prebuilds`);
             span.addTags({ nrOfCollectedPrebuilds: deletes.length });
@@ -162,4 +164,75 @@ export class WorkspaceGarbageCollector implements Job {
             span.finish();
         }
     }
+
+    /**
+     * This method garbageCollects a workspace. It deletes its contents and sets the workspaces 'contentDeletedTime'
+     * @param ctx
+     * @param ws
+     */
+    private async garbageCollectWorkspace(ctx: TraceContext, ws: WorkspaceOwnerAndSoftDeleted): Promise<boolean> {
+        const span = TraceContext.startSpan("garbageCollectWorkspace", ctx);
+
+        try {
+            const successfulDeleted = await this.deleteWorkspaceStorage({ span }, ws, true);
+            await this.workspaceDB
+                .trace({ span })
+                .updatePartial(ws.id, { contentDeletedTime: new Date().toISOString() });
+            return successfulDeleted;
+        } catch (err) {
+            TraceContext.setError({ span }, err);
+            throw err;
+        } finally {
+            span.finish();
+        }
+    }
+
+    /**
+     * @param ctx
+     * @param wsAndOwner
+     */
+    private async garbageCollectPrebuild(ctx: TraceContext, ws: WorkspaceAndOwner): Promise<boolean> {
+        const span = TraceContext.startSpan("garbageCollectPrebuild", ctx);
+
+        try {
+            const successfulDeleted = await this.deleteWorkspaceStorage({ span }, ws, true);
+            const now = new Date().toISOString();
+            // Note: soft & content deletion happens at the same time, because prebuilds are reproducible so there's no need for the extra time span.
+            await this.workspaceDB.trace({ span }).updatePartial(ws.id, {
+                contentDeletedTime: now,
+                softDeletedTime: now,
+                softDeleted: "gc",
+            });
+            return successfulDeleted;
+        } catch (err) {
+            TraceContext.setError({ span }, err);
+            throw err;
+        } finally {
+            span.finish();
+        }
+    }
+
+    /**
+     * Performs the actual deletion of a workspace's backups (and optionally, snapshots). It:
+     *  - throws an error if something went wrong during deletion
+     *  - returns true in case of successful deletion
+     * @param ws
+     * @param includeSnapshots
+     */
+    private async deleteWorkspaceStorage(
+        ctx: TraceContext,
+        ws: WorkspaceAndOwner,
+        includeSnapshots: boolean,
+    ): Promise<boolean> {
+        const span = TraceContext.startSpan("deleteWorkspaceStorage", ctx);
+        try {
+            await this.storageClient.deleteWorkspaceBackups(ws.ownerId, ws.id, includeSnapshots);
+        } catch (err) {
+            TraceContext.setError({ span }, err);
+            throw err;
+        } finally {
+            span.finish();
+        }
+        return true;
+    }
 }