merge envVarResolver and project env var managment to envVarService

Author: jeanp413

components/server/src/container-module.ts

@@ -104,7 +104,6 @@ import { WebsocketConnectionManager } from "./websocket/websocket-connection-man
 import { ConfigProvider } from "./workspace/config-provider";
 import { IContextParser, IPrefixContextParser } from "./workspace/context-parser";
 import { ContextParser } from "./workspace/context-parser-service";
-import { EnvVarResolver } from "./workspace/env-var-resolver";
 import { EnvvarPrefixParser } from "./workspace/envvar-prefix-context-parser";
 import { GitTokenScopeGuesser } from "./workspace/git-token-scope-guesser";
 import { GitTokenValidator } from "./workspace/git-token-validator";
@@ -259,7 +258,6 @@ export const productionContainerModule = new ContainerModule(
 
         bind(OrganizationService).toSelf().inSingletonScope();
         bind(ProjectsService).toSelf().inSingletonScope();
-        bind(EnvVarResolver).toSelf().inSingletonScope();
 
         bind(NewsletterSubscriptionController).toSelf().inSingletonScope();
 

components/server/src/prebuilds/prebuild-manager.ts

@@ -36,8 +36,8 @@ import { PrebuildRateLimiterConfig } from "../workspace/prebuild-rate-limiter";
 import { ErrorCodes, ApplicationError } from "@gitpod/gitpod-protocol/lib/messaging/error";
 import { UserAuthentication } from "../user/user-authentication";
 import { EntitlementService, MayStartWorkspaceResult } from "../billing/entitlement-service";
-import { EnvVarResolver } from "../workspace/env-var-resolver";
 import { WorkspaceService } from "../workspace/workspace-service";
+import { EnvVarService } from "../user/env-var-service";
 
 export class WorkspaceRunningError extends Error {
     constructor(msg: string, public instance: WorkspaceInstance) {
@@ -66,7 +66,7 @@ export class PrebuildManager {
     @inject(UserAuthentication) protected readonly userService: UserAuthentication;
     @inject(TeamDB) protected readonly teamDB: TeamDB;
     @inject(EntitlementService) protected readonly entitlementService: EntitlementService;
-    @inject(EnvVarResolver) private readonly envVarResolver: EnvVarResolver;
+    @inject(EnvVarService) protected readonly envVarService: EnvVarService;
 
     async abortPrebuildsForBranch(ctx: TraceContext, project: Project, user: User, branch: string): Promise<void> {
         const span = TraceContext.startSpan("abortPrebuildsForBranch", ctx);
@@ -230,7 +230,12 @@ export class PrebuildManager {
                 context.normalizedContextURL!,
             );
 
-            const envVarsPromise = this.envVarResolver.resolve(workspace);
+            const envVarsPromise = this.envVarService.resolveEnvVariables(
+                workspace.ownerId,
+                workspace.projectId,
+                workspace.type,
+                workspace.context,
+            );
 
             const prebuild = await this.workspaceDB.trace({ span }).findPrebuildByWorkspaceID(workspace.id)!;
             if (!prebuild) {
@@ -334,7 +339,12 @@ export class PrebuildManager {
             if (!prebuild) {
                 throw new Error("No prebuild found for workspace " + workspaceId);
             }
-            const envVars = await this.envVarResolver.resolve(workspace);
+            const envVars = await this.envVarService.resolveEnvVariables(
+                workspace.ownerId,
+                workspace.projectId,
+                workspace.type,
+                workspace.context,
+            );
             await this.workspaceStarter.startWorkspace({ span }, workspace, user, project, envVars);
             return { prebuildId: prebuild.id, wsid: workspace.id, done: false };
         } catch (err) {

components/server/src/projects/projects-service.spec.db.ts

@@ -120,64 +120,6 @@ describe("ProjectsService", async () => {
         );
     });
 
-    it("should let owners create, delete and get project env vars", async () => {
-        const ps = container.get(ProjectsService);
-        const project = await createTestProject(ps, org, owner);
-        await ps.setProjectEnvironmentVariable(owner.id, project.id, "FOO", "BAR", false);
-
-        const envVars = await ps.getProjectEnvironmentVariables(owner.id, project.id);
-        expect(envVars[0].name).to.equal("FOO");
-
-        const envVarById = await ps.getProjectEnvironmentVariableById(owner.id, envVars[0].id);
-        expect(envVarById?.name).to.equal("FOO");
-
-        await ps.deleteProjectEnvironmentVariable(owner.id, envVars[0].id);
-
-        await expectError(ErrorCodes.NOT_FOUND, () => ps.getProjectEnvironmentVariableById(owner.id, envVars[0].id));
-
-        const emptyEnvVars = await ps.getProjectEnvironmentVariables(owner.id, project.id);
-        expect(emptyEnvVars.length).to.equal(0);
-    });
-
-    it("should not let members create, delete but allow get project env vars", async () => {
-        const ps = container.get(ProjectsService);
-        const project = await createTestProject(ps, org, owner);
-        await ps.setProjectEnvironmentVariable(owner.id, project.id, "FOO", "BAR", false);
-
-        const envVars = await ps.getProjectEnvironmentVariables(member.id, project.id);
-        expect(envVars[0].name).to.equal("FOO");
-
-        const envVarById = await ps.getProjectEnvironmentVariableById(member.id, envVars[0].id);
-        expect(envVarById?.name).to.equal("FOO");
-
-        await expectError(ErrorCodes.PERMISSION_DENIED, () =>
-            ps.deleteProjectEnvironmentVariable(member.id, envVars[0].id),
-        );
-
-        await expectError(ErrorCodes.PERMISSION_DENIED, () =>
-            ps.setProjectEnvironmentVariable(member.id, project.id, "FOO", "BAR", false),
-        );
-    });
-
-    it("should not let strangers create, delete and get project env vars", async () => {
-        const ps = container.get(ProjectsService);
-        const project = await createTestProject(ps, org, owner);
-
-        await ps.setProjectEnvironmentVariable(owner.id, project.id, "FOO", "BAR", false);
-
-        const envVars = await ps.getProjectEnvironmentVariables(owner.id, project.id);
-        expect(envVars[0].name).to.equal("FOO");
-
-        // let's try to get the env var as a stranger
-        await expectError(ErrorCodes.NOT_FOUND, () => ps.getProjectEnvironmentVariableById(stranger.id, envVars[0].id));
-
-        // let's try to delete the env var as a stranger
-        await expectError(ErrorCodes.NOT_FOUND, () => ps.deleteProjectEnvironmentVariable(stranger.id, envVars[0].id));
-
-        // let's try to get the env vars as a stranger
-        await expectError(ErrorCodes.NOT_FOUND, () => ps.getProjectEnvironmentVariables(stranger.id, project.id));
-    });
-
     it("should findProjects", async () => {
         const ps = container.get(ProjectsService);
         const project = await createTestProject(ps, org, owner);

components/server/src/projects/projects-service.ts

@@ -12,7 +12,6 @@ import {
     CreateProjectParams,
     FindPrebuildsParams,
     Project,
-    ProjectEnvVar,
     User,
     PrebuildEvent,
 } from "@gitpod/gitpod-protocol";
@@ -386,41 +385,6 @@ export class ProjectsService {
         return this.projectDB.updateProject(partialProject);
     }
 
-    async setProjectEnvironmentVariable(
-        userId: string,
-        projectId: string,
-        name: string,
-        value: string,
-        censored: boolean,
-    ): Promise<void> {
-        await this.auth.checkPermissionOnProject(userId, "write_info", projectId);
-        return this.projectDB.setProjectEnvironmentVariable(projectId, name, value, censored);
-    }
-
-    async getProjectEnvironmentVariables(userId: string, projectId: string): Promise<ProjectEnvVar[]> {
-        await this.auth.checkPermissionOnProject(userId, "read_info", projectId);
-        return this.projectDB.getProjectEnvironmentVariables(projectId);
-    }
-
-    async getProjectEnvironmentVariableById(userId: string, variableId: string): Promise<ProjectEnvVar> {
-        const result = await this.projectDB.getProjectEnvironmentVariableById(variableId);
-        if (!result) {
-            throw new ApplicationError(ErrorCodes.NOT_FOUND, `Environment Variable ${variableId} not found.`);
-        }
-        try {
-            await this.auth.checkPermissionOnProject(userId, "read_info", result.projectId);
-        } catch (err) {
-            throw new ApplicationError(ErrorCodes.NOT_FOUND, `Environment Variable ${variableId} not found.`);
-        }
-        return result;
-    }
-
-    async deleteProjectEnvironmentVariable(userId: string, variableId: string): Promise<void> {
-        const variable = await this.getProjectEnvironmentVariableById(userId, variableId);
-        await this.auth.checkPermissionOnProject(userId, "write_info", variable.projectId);
-        return this.projectDB.deleteProjectEnvironmentVariable(variableId);
-    }
-
     async isProjectConsideredInactive(userId: string, projectId: string): Promise<boolean> {
         await this.auth.checkPermissionOnProject(userId, "read_info", projectId);
         const usage = await this.projectDB.getProjectUsage(projectId);