wip

geropl · akosyakov · commit bf39da27a372 · 2023-08-09T06:33:25.000Z
diff --git a/components/server/src/api/user.spec.ts b/components/server/src/api/user.spec.ts
@@ -8,7 +8,6 @@ import { suite, test } from "@testdeck/mocha";
 import { APIUserService } from "./user";
 import { Container } from "inversify";
 import { testContainer } from "@gitpod/gitpod-db/lib";
-import { WorkspaceStarter } from "../workspace/workspace-starter";
 import { UserAuthentication } from "../user/user-authentication";
 import { BlockUserRequest, BlockUserResponse } from "@gitpod/public-api/lib/gitpod/experimental/v1/user_pb";
 import { User } from "@gitpod/gitpod-protocol";
@@ -18,22 +17,24 @@ import { TraceContext } from "@gitpod/gitpod-protocol/lib/util/tracing";
 import { v4 as uuidv4 } from "uuid";
 import { ConnectError, Code } from "@bufbuild/connect";
 import * as chai from "chai";
+import { WorkspaceService } from "../workspace/workspace-service";
 
 const expect = chai.expect;
 
 @suite()
 export class APIUserServiceSpec {
     private container: Container;
-    private workspaceStarterMock: WorkspaceStarter = {
+    private workspaceStarterMock: WorkspaceService = {
         stopRunningWorkspacesForUser: async (
             ctx: TraceContext,
-            userID: string,
+            userId: string,
+            userIdToStop: string,
             reason: string,
             policy?: StopWorkspacePolicy,
         ): Promise<Workspace[]> => {
             return [];
         },
-    } as WorkspaceStarter;
+    } as WorkspaceService;
     private userServiceMock: UserAuthentication = {
         blockUser: async (targetUserId: string, block: boolean): Promise<User> => {
             return {
@@ -45,7 +46,7 @@ export class APIUserServiceSpec {
     async before() {
         this.container = testContainer.createChild();
 
-        this.container.bind(WorkspaceStarter).toConstantValue(this.workspaceStarterMock);
+        this.container.bind(WorkspaceService).toConstantValue(this.workspaceStarterMock);
         this.container.bind(UserAuthentication).toConstantValue(this.userServiceMock);
         this.container.bind(APIUserService).toSelf().inSingletonScope();
     }
diff --git a/components/server/src/api/user.ts b/components/server/src/api/user.ts
@@ -25,13 +25,11 @@ import {
 } from "@gitpod/public-api/lib/gitpod/experimental/v1/user_pb";
 import { WorkspaceStarter } from "../workspace/workspace-starter";
 import { UserAuthentication } from "../user/user-authentication";
-import { validate } from "uuid";
-import { StopWorkspacePolicy } from "@gitpod/ws-manager/lib";
-import { log } from "@gitpod/gitpod-protocol/lib/util/logging";
+import { WorkspaceService } from "../workspace/workspace-service";
 
 @injectable()
 export class APIUserService implements ServiceImpl<typeof UserServiceInterface> {
-    @inject(WorkspaceStarter) protected readonly workspaceStarter: WorkspaceStarter;
+    @inject(WorkspaceStarter) protected readonly workspaceService: WorkspaceService;
     @inject(UserAuthentication) protected readonly userService: UserAuthentication;
 
     public async getAuthenticatedUser(req: GetAuthenticatedUserRequest): Promise<GetAuthenticatedUserResponse> {
@@ -59,39 +57,41 @@ export class APIUserService implements ServiceImpl<typeof UserServiceInterface>
     }
 
     public async blockUser(req: BlockUserRequest): Promise<BlockUserResponse> {
-        const { userId, reason } = req;
+        throw new ConnectError("unimplemented", Code.Unimplemented);
+        // TODO(gpl) Had to comment this out because of missing authentication info: Who is executing this?
+        // const { userId, reason } = req;
 
-        if (!userId) {
-            throw new ConnectError("userId is a required parameter", Code.InvalidArgument);
-        }
-        if (!validate(userId)) {
-            throw new ConnectError("userId must be a valid uuid", Code.InvalidArgument);
-        }
-        if (!reason) {
-            throw new ConnectError("reason is a required parameter", Code.InvalidArgument);
-        }
+        // if (!userId) {
+        //     throw new ConnectError("userId is a required parameter", Code.InvalidArgument);
+        // }
+        // if (!validate(userId)) {
+        //     throw new ConnectError("userId must be a valid uuid", Code.InvalidArgument);
+        // }
+        // if (!reason) {
+        //     throw new ConnectError("reason is a required parameter", Code.InvalidArgument);
+        // }
 
-        // TODO: Once connect-node supports middlewares, lift the tracing into the middleware.
-        const trace = {};
-        await this.userService.blockUser(userId, true);
-        log.info(`Blocked user ${userId}.`, {
-            userId,
-            reason,
-        });
+        // // TODO: Once connect-node supports middlewares, lift the tracing into the middleware.
+        // const trace = {};
+        // await this.userService.blockUser(userId, true);
+        // log.info(`Blocked user ${userId}.`, {
+        //     userId,
+        //     reason,
+        // });
 
-        const stoppedWorkspaces = await this.workspaceStarter.stopRunningWorkspacesForUser(
-            trace,
-            userId,
-            reason,
-            StopWorkspacePolicy.IMMEDIATELY,
-        );
+        // const stoppedWorkspaces = await this.workspaceService.stopRunningWorkspacesForUser(
+        //     trace,
+        //     userId,
+        //     reason,
+        //     StopWorkspacePolicy.IMMEDIATELY,
+        // );
 
-        log.info(`Stopped ${stoppedWorkspaces.length} workspaces in response to BlockUser.`, {
-            userId,
-            reason,
-            workspaceIds: stoppedWorkspaces.map((w) => w.id),
-        });
+        // log.info(`Stopped ${stoppedWorkspaces.length} workspaces in response to BlockUser.`, {
+        //     userId,
+        //     reason,
+        //     workspaceIds: stoppedWorkspaces.map((w) => w.id),
+        // });
 
-        return new BlockUserResponse();
+        // return new BlockUserResponse();
     }
 }
diff --git a/components/server/src/workspace/workspace-service.ts b/components/server/src/workspace/workspace-service.ts
@@ -98,6 +98,14 @@ export class WorkspaceService {
         return workspace;
     }
 
+    private async doGetWorkspace(workspaceId: string, workspaceDB?: WorkspaceDB): Promise<Workspace> {
+        const workspace = await (workspaceDB || this.db).findById(workspaceId);
+        if (!workspace || !!workspace.softDeleted || workspace.deleted) {
+            throw new ApplicationError(ErrorCodes.NOT_FOUND, "Workspace not found.");
+        }
+        return workspace;
+    }
+
     async getOwnerToken(userId: string, workspaceId: string): Promise<string> {
         await this.auth.checkPermissionOnWorkspace(userId, "access", workspaceId);
 
@@ -131,6 +139,7 @@ export class WorkspaceService {
         });
     }
 
+    // stopWorkspace and related methods below
     async stopWorkspace(
         userId: string,
         workspaceId: string,
@@ -148,6 +157,29 @@ export class WorkspaceService {
         await this.workspaceStarter.stopWorkspaceInstance({}, instance.id, instance.region, reason, policy);
     }
 
+    public async stopRunningWorkspacesForUser(
+        ctx: TraceContext,
+        userId: string,
+        userIdToStop: string,
+        reason: string,
+        policy?: StopWorkspacePolicy,
+    ): Promise<Workspace[]> {
+        const infos = await this.db.findRunningInstancesWithWorkspaces(undefined, userIdToStop);
+        await Promise.all(
+            infos.map(async (info) => {
+                await this.auth.checkPermissionOnWorkspace(userId, "stop", info.workspace.id);
+                await this.workspaceStarter.stopWorkspaceInstance(
+                    ctx,
+                    info.latestInstance.id,
+                    info.latestInstance.region,
+                    reason,
+                    policy,
+                );
+            }),
+        );
+        return infos.map((instance) => instance.workspace);
+    }
+
     /**
      * This method does nothing beyond marking the given workspace as 'softDeleted' with the given cause and sets the 'softDeletedTime' to now.
      * The actual deletion happens as part of the regular workspace garbage collection.
diff --git a/components/server/src/workspace/workspace-starter.ts b/components/server/src/workspace/workspace-starter.ts
@@ -95,11 +95,11 @@ import {
     PortSpec,
     PortVisibility,
     StartWorkspaceRequest,
-    StopWorkspacePolicy,
-    StopWorkspaceRequest,
     WorkspaceMetadata,
     WorkspaceType,
     PortProtocol,
+    StopWorkspacePolicy,
+    StopWorkspaceRequest,
 } from "@gitpod/ws-manager/lib/core_pb";
 import * as grpc from "@grpc/grpc-js";
 import * as crypto from "crypto";
@@ -466,28 +466,6 @@ export class WorkspaceStarter {
         await client.stopWorkspace(ctx, req);
     }
 
-    public async stopRunningWorkspacesForUser(
-        ctx: TraceContext,
-        userID: string,
-        reason: string,
-        policy?: StopWorkspacePolicy,
-    ): Promise<Workspace[]> {
-        const workspaceDb = this.workspaceDb.trace(ctx);
-        const instances = await workspaceDb.findRunningInstancesWithWorkspaces(undefined, userID);
-        await Promise.all(
-            instances.map((instance) =>
-                this.stopWorkspaceInstance(
-                    ctx,
-                    instance.latestInstance.id,
-                    instance.latestInstance.region,
-                    reason,
-                    policy,
-                ),
-            ),
-        );
-        return instances.map((instance) => instance.workspace);
-    }
-
     private async checkBlockedRepository(user: User, contextURL: string) {
         const blockedRepository = await this.blockedRepositoryDB.findBlockedRepositoryByURL(contextURL);
         if (!blockedRepository) return;
