[server] Simplify class selection

Author: Furisto

components/server/src/workspace/workspace-classes.spec.ts

@@ -17,11 +17,6 @@ let config: WorkspaceClassesConfig = [
         description: "Up to 4 vCPU, 8 GB memory, 30GB storage",
         powerups: 1,
         deprecated: false,
-        resources: {
-            cpu: 4,
-            memory: 8,
-            storage: 30,
-        },
     },
 ];
 
@@ -36,11 +31,6 @@ config.push({
     marker: {
         moreResources: true,
     },
-    resources: {
-        cpu: 8,
-        memory: 16,
-        storage: 50,
-    },
 });
 
 config.push({
@@ -51,37 +41,50 @@ config.push({
     description: "Up to 8 vCPU, 16 GB memory, 50GB storage",
     powerups: 2,
     deprecated: true,
-    resources: {
-        cpu: 8,
-        memory: 16,
-        storage: 50,
+    marker: {
+        moreResources: true,
     },
 });
 
 describe("workspace-classes", function () {
     describe("can substitute", function () {
         it("classes are the same", function () {
-            const classId = WorkspaceClasses.canSubstitute("g1-large", "g1-large", config);
+            const classId = WorkspaceClasses.selectClassForRegular("g1-large", "g1-large", config);
+            expect(classId).to.be.equal("g1-large");
+        });
+
+        it("prebuild has more resources, substitute has not", function () {
+            const classId = WorkspaceClasses.selectClassForRegular("g1-large", "g1-standard", config);
             expect(classId).to.be.equal("g1-large");
         });
 
-        it("substitute is acceptable", function () {
-            const classId = WorkspaceClasses.canSubstitute("g1-standard", "g1-large", config);
+        it("prebuild has more resources, substitute also has more resources", function () {
+            const classId = WorkspaceClasses.selectClassForRegular("g1-large", "g1-large", config);
             expect(classId).to.be.equal("g1-large");
         });
 
-        it("substitute is deprecated", function () {
-            const classId = WorkspaceClasses.canSubstitute("g1-standard", "g1-deprecated", config);
+        it("prebuild has more resources, substitute has not, prebuild is deprecated", function () {
+            const classId = WorkspaceClasses.selectClassForRegular("g1-deprecated", "g1-standard", config);
             expect(classId).to.be.equal("g1-large");
         });
 
-        it("current is deprecated, substitute not acceptable", function () {
-            const classId = WorkspaceClasses.canSubstitute("g1-deprecated", "g1-standard", config);
+        it("prebuild has more resources, substitute has not, prebuild not deprecated", function () {
+            const classId = WorkspaceClasses.selectClassForRegular("g1-large", "g1-standard", config);
             expect(classId).to.be.equal("g1-large");
         });
 
+        it("prebuild does not have more resources, return substitute", function () {
+            const classId = WorkspaceClasses.selectClassForRegular("g1-standard", "g1-large", config);
+            expect(classId).to.be.equal("g1-large");
+        });
+
+        it("prebuild does not have more resources, substitute unknown", function () {
+            const classId = WorkspaceClasses.selectClassForRegular("g1-standard", "g1-unknown", config);
+            expect(classId).to.be.equal("g1-standard");
+        });
+
         it("substitute is not acceptable", function () {
-            const classId = WorkspaceClasses.canSubstitute("g1-large", "g1-standard", config);
+            const classId = WorkspaceClasses.selectClassForRegular("g1-large", "g1-standard", config);
             expect(classId).to.be.equal("g1-large");
         });
     });

components/server/src/workspace/workspace-classes.ts

@@ -41,18 +41,6 @@ export interface WorkspaceClassConfig {
         // Marks this class as the one that users marked with "GetMoreResources" receive
         moreResources: boolean;
     };
-
-    // The resources that this class provides
-    resources: WorkspaceClassResources;
-}
-
-export interface WorkspaceClassResources {
-    // Storage in gigabyte
-    storage: number;
-    // Number of cpus
-    cpu: number;
-    // Memory in gigabyte
-    memory: number;
 }
 
 export namespace WorkspaceClasses {
@@ -182,19 +170,11 @@ export namespace WorkspaceClasses {
     }
 
     /**
-     * Checks if the current class can be replaced by another class
-     * - If both classes are the same the current class will be returned
-     * - If the proposed substitute class has at least as much resources as the current class replace it
-     * - If the substitute does not provide sufficient resources
-     *   - If current class is deprecated
-     *     - Try to find another class that provides at least as much resources as the deprecated one
-     *     - If this also fails, return default class
-     *   - If current class is not deprecated return current class
      * @param currentClassId
      * @param substituteClassId
      * @param classes
      */
-    export function canSubstitute(
+    export function selectClassForRegular(
         currentClassId: string,
         substituteClassId: string | undefined,
         classes: WorkspaceClassesConfig,
@@ -206,50 +186,22 @@ export namespace WorkspaceClasses {
         const current = classes.find((c) => c.id === currentClassId);
         let substitute = classes.find((c) => c.id === substituteClassId);
 
-        if (!current) {
-            throw new Error("class not defined: " + currentClassId);
-        }
-
-        if (!substitute) {
-            throw new Error("class not defined: " + substituteClassId);
-        }
-
-        if (substitute.deprecated) {
-            substitute = findClosestAlternative(substitute, classes);
-        }
-
-        if (substitute && providesMinimalResources(substitute, current)) {
-            return substitute.id;
-        }
-
-        if (current.deprecated) {
-            const alternative = findClosestAlternative(current, classes);
-            if (!alternative) {
-                return getDefaultId(classes);
+        if (current?.marker?.moreResources) {
+            if (substitute?.marker?.moreResources) {
+                return substitute?.id;
             } else {
-                return alternative.id;
+                if (current.deprecated) {
+                    return getMoreResourcesIdOrDefault(classes);
+                } else {
+                    return current.id;
+                }
+            }
+        } else {
+            if (substitute?.id) {
+                return substitute.id;
+            } else {
+                return getDefaultId(classes);
             }
         }
-
-        return current.id;
-    }
-
-    function providesMinimalResources(class1: WorkspaceClassConfig, class2: WorkspaceClassConfig): boolean {
-        return (
-            class1.category === class2.category &&
-            class1.resources.cpu >= class2.resources.cpu &&
-            class1.resources.memory >= class2.resources.memory &&
-            class1.resources.storage >= class2.resources.storage
-        );
-    }
-
-    function findClosestAlternative(
-        current: WorkspaceClassConfig,
-        classes: WorkspaceClassesConfig,
-    ): WorkspaceClassConfig | undefined {
-        return classes
-            .filter((cl) => !cl.deprecated)
-            .sort((a, b) => a.resources.storage - b.resources.storage)
-            .find((cl) => providesMinimalResources(cl, current));
     }
 }

components/server/src/workspace/workspace-starter.spec.ts

@@ -428,11 +428,6 @@ class WorkspaceClassTestBuilder {
                 description: "Up to 4 vCPU, 8 GB memory, 30GB storage",
                 powerups: 1,
                 deprecated: false,
-                resources: {
-                    cpu: 4,
-                    memory: 8,
-                    storage: 30,
-                },
             },
         ];
 
@@ -447,11 +442,6 @@ class WorkspaceClassTestBuilder {
             marker: {
                 moreResources: this.hasMoreResources,
             },
-            resources: {
-                cpu: 8,
-                memory: 16,
-                storage: 50,
-            },
         });
 
         config.push({
@@ -462,11 +452,6 @@ class WorkspaceClassTestBuilder {
             description: "Up to 8 vCPU, 16 GB memory, 50GB storage",
             powerups: 2,
             deprecated: true,
-            resources: {
-                cpu: 8,
-                memory: 16,
-                storage: 50,
-            },
         });
 
         const workspaceDb = new MockWorkspaceDb(!!this.basedOnPrebuild);

components/server/src/workspace/workspace-starter.ts

@@ -210,7 +210,7 @@ export async function getWorkspaceClassForInstance(
                         config,
                         entitlementService,
                     );
-                    workspaceClass = WorkspaceClasses.canSubstitute(prebuildClass, userClass, config);
+                    workspaceClass = WorkspaceClasses.selectClassForRegular(prebuildClass, userClass, config);
                 } else if (user.additionalData?.workspaceClasses?.regular) {
                     workspaceClass = user.additionalData?.workspaceClasses?.regular;
                 }