pass workspace type when deleting volume snapshots

Author: sagor999

components/gitpod-protocol/src/protocol.ts

@@ -659,6 +659,11 @@ export interface VolumeSnapshot {
     volumeHandle: string;
 }
 
+export interface VolumeSnapshotWithWSType {
+    vs: VolumeSnapshot;
+    wsType: WorkspaceType;
+}
+
 export type SnapshotState = "pending" | "available" | "error";
 
 export interface Workspace {

components/server/src/workspace/garbage-collector.ts

@@ -6,7 +6,7 @@
 
 import { injectable, inject } from "inversify";
 import { ConsensusLeaderQorum } from "../consensus/consensus-leader-quorum";
-import { Disposable } from "@gitpod/gitpod-protocol";
+import { Disposable, VolumeSnapshotWithWSType } from "@gitpod/gitpod-protocol";
 import { log } from "@gitpod/gitpod-protocol/lib/util/logging";
 import { WorkspaceDeletionService } from "./workspace-deletion-service";
 import * as opentracing from "opentracing";
@@ -166,23 +166,36 @@ export class WorkspaceGarbageCollector {
     protected async deleteOutdatedVolumeSnapshots() {
         const span = opentracing.globalTracer().startSpan("deleteOutdatedVolumeSnapshots");
         try {
-            const workspaces = await this.workspaceDB
+            const workspaceIds = await this.workspaceDB
                 .trace({ span })
                 .findVolumeSnapshotWorkspacesForGC(this.config.workspaceGarbageCollection.chunkLimit);
-            const volumeSnapshots = await Promise.all(
-                workspaces.map((ws) =>
+            const volumeSnapshotsWithWSPromises = workspaceIds.map(async (wsId) => {
+                const [vss, ws] = await Promise.all([
                     this.workspaceDB
                         .trace({ span })
-                        .findVolumeSnapshotForGCByWorkspaceId(ws, this.config.workspaceGarbageCollection.chunkLimit),
-                ),
-            );
+                        .findVolumeSnapshotForGCByWorkspaceId(wsId, this.config.workspaceGarbageCollection.chunkLimit),
+                    this.workspaceDB.trace({ span }).findById(wsId),
+                ]);
+                return { wsId, ws, vss };
+            });
 
-            await Promise.all(
-                volumeSnapshots.map((vss) =>
+            // We're doing the actual deletion in a sync for-loop tp avoid quadratic explosion of requests
+            for await (const { wsId, ws, vss } of volumeSnapshotsWithWSPromises) {
+                if (!ws) {
+                    log.error(`Workspace ${wsId} not found while looking for outdated volume snapshots`);
+                    continue; // Still, continue deleting the others
+                }
+                await Promise.all(
                     // skip the first volume snapshot, as it is most recent, and then pass the rest into deletion
-                    vss.slice(1).map((vs) => this.deletionService.garbageCollectVolumeSnapshot({ span }, vs)),
-                ),
-            );
+                    vss.slice(1).map((vs) => {
+                        let vswst: VolumeSnapshotWithWSType = {
+                            vs,
+                            wsType: ws?.type,
+                        };
+                        return this.deletionService.garbageCollectVolumeSnapshot({ span }, vswst);
+                    }),
+                );
+            }
         } catch (err) {
             TraceContext.setError({ span }, err);
             throw err;

components/server/src/workspace/workspace-deletion-service.ts

@@ -5,7 +5,7 @@
  */
 
 import { inject, injectable } from "inversify";
-import { WorkspaceSoftDeletion, VolumeSnapshot } from "@gitpod/gitpod-protocol";
+import { WorkspaceSoftDeletion, VolumeSnapshotWithWSType } from "@gitpod/gitpod-protocol";
 import {
     WorkspaceDB,
     WorkspaceAndOwner,
@@ -19,6 +19,7 @@ import { TraceContext } from "@gitpod/gitpod-protocol/lib/util/tracing";
 import { WorkspaceManagerClientProvider } from "@gitpod/ws-manager/lib/client-provider";
 import { DeleteVolumeSnapshotRequest } from "@gitpod/ws-manager/lib";
 import { log } from "@gitpod/gitpod-protocol/lib/util/logging";
+import { WorkspaceType } from "@gitpod/ws-manager/lib/core_pb";
 
 @injectable()
 export class WorkspaceDeletionService {
@@ -121,7 +122,20 @@ export class WorkspaceDeletionService {
             let vss = await this.db
                 .trace({ span })
                 .findVolumeSnapshotForGCByWorkspaceId(ws.id, this.config.workspaceGarbageCollection.chunkLimit);
-            await Promise.all(vss.map((vs) => this.garbageCollectVolumeSnapshot({ span }, vs)));
+            // we need full workspace info here to find its type
+            let fullWS = await this.db.trace({ span }).findById(ws.id);
+            if (!fullWS) {
+                throw new Error(`Workspace ${ws.id} not found while deleting its storage`);
+            }
+            let wsType = fullWS.type;
+            let vssType = vss.map((vs) => {
+                let vswst: VolumeSnapshotWithWSType = {
+                    vs,
+                    wsType: wsType,
+                };
+                return vswst;
+            });
+            await Promise.all(vssType.map((vs) => this.garbageCollectVolumeSnapshot({ span }, vs)));
         } catch (err) {
             TraceContext.setError({ span }, err);
             throw err;
@@ -141,7 +155,7 @@ export class WorkspaceDeletionService {
      * @param ctx
      * @param vs
      */
-    public async garbageCollectVolumeSnapshot(ctx: TraceContext, vs: VolumeSnapshot): Promise<boolean> {
+    public async garbageCollectVolumeSnapshot(ctx: TraceContext, vs: VolumeSnapshotWithWSType): Promise<boolean> {
         const span = TraceContext.startSpan("garbageCollectVolumeSnapshot", ctx);
 
         try {
@@ -161,8 +175,24 @@ export class WorkspaceDeletionService {
                     this.config.installationShortname,
                 );
                 const req = new DeleteVolumeSnapshotRequest();
-                req.setId(vs.id);
-                req.setVolumeHandle(vs.volumeHandle);
+                req.setId(vs.vs.id);
+                req.setVolumeHandle(vs.vs.volumeHandle);
+                let type: WorkspaceType = WorkspaceType.REGULAR;
+                switch (vs.wsType) {
+                    case "regular": {
+                        type = WorkspaceType.REGULAR;
+                        break;
+                    }
+                    case "prebuild": {
+                        type = WorkspaceType.PREBUILD;
+                        break;
+                    }
+                    default: {
+                        throw new Error(`wds: deleteVolumeSnapshot unknown workspace type '${vs.wsType}' detected`);
+                        break;
+                    }
+                }
+                req.setWsType(type);
 
                 let softDelete = true;
                 // if we did not delete volume snapshot yet and this is our last cluster, make sure we perform hard delete
@@ -184,7 +214,7 @@ export class WorkspaceDeletionService {
                 }
             }
             if (wasDeleted) {
-                await this.db.trace({ span }).deleteVolumeSnapshot(vs.id);
+                await this.db.trace({ span }).deleteVolumeSnapshot(vs.vs.id);
             }
 
             return wasDeleted;

components/ws-manager-api/core.proto

@@ -232,6 +232,9 @@ message DeleteVolumeSnapshotRequest{
 
     // soft_delete controls whether manager should attempt to restore volume snapshot from handle if it doesn't exist in the cluster yet
     bool soft_delete = 3;
+
+    // ws_type is the type of workspace (prebuild or regular) to which this volume snapshot belongs
+    WorkspaceType ws_type = 4;
 }
 
 message DeleteVolumeSnapshotResponse {