[server] Introduce RequestContext

Author: geropl

components/gitpod-protocol/src/analytics.ts

@@ -6,9 +6,7 @@
 
 export const IAnalyticsWriter = Symbol("IAnalyticsWriter");
 
-type Identity =
-    | { userId: string | number; anonymousId?: string | number }
-    | { userId?: string | number; anonymousId: string | number };
+type Identity = { userId?: string | number; anonymousId?: string | number; subjectId?: string };
 
 interface Message {
     messageId?: string;

components/gitpod-protocol/src/util/logging.ts

@@ -17,6 +17,7 @@ export interface LogContext {
     organizationId?: string;
     sessionId?: string;
     userId?: string;
+    subjectId?: string;
     workspaceId?: string;
     instanceId?: string;
 }

components/public-api/gitpod/experimental/v2/organization.proto

@@ -111,6 +111,9 @@ message GetOrganizationSettingsResponse {
 message CreateOrganizationRequest {
     // name is the organization name
     string name = 1;
+
+    // the id of the owning user
+    optional string owner_id = 2;
 }
 
 message CreateOrganizationResponse {

components/public-api/go/experimental/v2/organization.pb.go

@@ -5,7 +5,6 @@
  */
 
 import { HandlerContext, ServiceImpl } from "@connectrpc/connect";
-import { User } from "@gitpod/gitpod-protocol";
 import { HelloService } from "@gitpod/public-api/lib/gitpod/experimental/v1/dummy_connect";
 import {
     LotsOfRepliesRequest,
@@ -14,27 +13,28 @@ import {
     SayHelloResponse,
 } from "@gitpod/public-api/lib/gitpod/experimental/v1/dummy_pb";
 import { injectable } from "inversify";
+import { ctx } from "../util/request-context";
 
 @injectable()
 export class HelloServiceAPI implements ServiceImpl<typeof HelloService> {
-    async sayHello(req: SayHelloRequest, context: HandlerContext): Promise<SayHelloResponse> {
+    async sayHello(req: SayHelloRequest, _: HandlerContext): Promise<SayHelloResponse> {
         const response = new SayHelloResponse();
-        response.reply = "Hello " + this.getSubject(context);
+        response.reply = "Hello " + getSubject();
         return response;
     }
-    async *lotsOfReplies(req: LotsOfRepliesRequest, context: HandlerContext): AsyncGenerator<LotsOfRepliesResponse> {
+    async *lotsOfReplies(req: LotsOfRepliesRequest, _: HandlerContext): AsyncGenerator<LotsOfRepliesResponse> {
         let count = req.previousCount || 0;
-        while (!context.signal.aborted) {
+        while (!ctx().signal.aborted) {
             const response = new LotsOfRepliesResponse();
-            response.reply = `Hello ${this.getSubject(context)} ${count}`;
+            response.reply = `Hello ${getSubject()} ${count}`;
             response.count = count;
             yield response;
             count++;
             await new Promise((resolve) => setTimeout(resolve, 30000));
         }
     }
+}
 
-    private getSubject(context: HandlerContext): string {
-        return User.getName(context.user) || "World";
-    }
+function getSubject(): string {
+    return ctx().subjectId?.toString() || "World";
 }

components/public-api/typescript/src/gitpod/experimental/v2/organization_pb.ts

@@ -38,6 +38,8 @@ import {
 import { PublicAPIConverter } from "@gitpod/gitpod-protocol/lib/public-api-converter";
 import { OrganizationService } from "../orgs/organization-service";
 import { PaginationResponse } from "@gitpod/public-api/lib/gitpod/experimental/v2/pagination_pb";
+import { ctx, userId } from "../util/request-context";
+import { ApplicationError, ErrorCodes } from "@gitpod/gitpod-protocol/lib/messaging/error";
 
 @injectable()
 export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationServiceInterface> {
@@ -48,38 +50,33 @@ export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationSe
         private readonly apiConverter: PublicAPIConverter,
     ) {}
 
-    async createOrganization(
-        req: CreateOrganizationRequest,
-        context: HandlerContext,
-    ): Promise<CreateOrganizationResponse> {
-        const org = await this.orgService.createOrganization(context.user.id, req.name);
+    async createOrganization(req: CreateOrganizationRequest, _: HandlerContext): Promise<CreateOrganizationResponse> {
+        const ownerId = req.ownerId || ctx().subjectId?.userId();
+        if (!ownerId) {
+            throw new ApplicationError(ErrorCodes.BAD_REQUEST, "No userId available");
+        }
+        const org = await this.orgService.createOrganization(ownerId, req.name);
         const response = new CreateOrganizationResponse();
         response.organization = this.apiConverter.toOrganization(org);
         return response;
     }
 
-    async getOrganization(req: GetOrganizationRequest, context: HandlerContext): Promise<GetOrganizationResponse> {
-        const org = await this.orgService.getOrganization(context.user.id, req.organizationId);
+    async getOrganization(req: GetOrganizationRequest, _: HandlerContext): Promise<GetOrganizationResponse> {
+        const org = await this.orgService.getOrganization(userId(), req.organizationId);
         const response = new GetOrganizationResponse();
         response.organization = this.apiConverter.toOrganization(org);
         return response;
     }
 
-    async updateOrganization(
-        req: UpdateOrganizationRequest,
-        context: HandlerContext,
-    ): Promise<UpdateOrganizationResponse> {
-        await this.orgService.updateOrganization(context.user.id, req.organizationId, {
+    async updateOrganization(req: UpdateOrganizationRequest, _: HandlerContext): Promise<UpdateOrganizationResponse> {
+        await this.orgService.updateOrganization(userId(), req.organizationId, {
             name: req.name,
         });
         return new UpdateOrganizationResponse();
     }
 
-    async listOrganizations(
-        req: ListOrganizationsRequest,
-        context: HandlerContext,
-    ): Promise<ListOrganizationsResponse> {
-        const orgs = await this.orgService.listOrganizations(context.user.id, {
+    async listOrganizations(req: ListOrganizationsRequest, _: HandlerContext): Promise<ListOrganizationsResponse> {
+        const orgs = await this.orgService.listOrganizations(userId(), {
             limit: req.pagination?.pageSize || 100,
             offset: (req.pagination?.page || 0) * (req.pagination?.pageSize || 0),
         });
@@ -90,46 +87,43 @@ export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationSe
         return response;
     }
 
-    async deleteOrganization(
-        req: DeleteOrganizationRequest,
-        context: HandlerContext,
-    ): Promise<DeleteOrganizationResponse> {
-        await this.orgService.deleteOrganization(context.user.id, req.organizationId);
+    async deleteOrganization(req: DeleteOrganizationRequest, _: HandlerContext): Promise<DeleteOrganizationResponse> {
+        await this.orgService.deleteOrganization(userId(), req.organizationId);
         return new DeleteOrganizationResponse();
     }
 
     async getOrganizationInvitation(
         req: GetOrganizationInvitationRequest,
-        context: HandlerContext,
+        _: HandlerContext,
     ): Promise<GetOrganizationInvitationResponse> {
-        const invitation = await this.orgService.getOrCreateInvite(context.user.id, req.organizationId);
+        const invitation = await this.orgService.getOrCreateInvite(userId(), req.organizationId);
         const response = new GetOrganizationInvitationResponse();
         response.invitationId = invitation.id;
         return response;
     }
 
-    async joinOrganization(req: JoinOrganizationRequest, context: HandlerContext): Promise<JoinOrganizationResponse> {
-        const orgId = await this.orgService.joinOrganization(context.user.id, req.invitationId);
+    async joinOrganization(req: JoinOrganizationRequest, _: HandlerContext): Promise<JoinOrganizationResponse> {
+        const orgId = await this.orgService.joinOrganization(userId(), req.invitationId);
         const result = new JoinOrganizationResponse();
         result.organizationId = orgId;
         return result;
     }
 
     async resetOrganizationInvitation(
         req: ResetOrganizationInvitationRequest,
-        context: HandlerContext,
+        _: HandlerContext,
     ): Promise<ResetOrganizationInvitationResponse> {
-        const inviteId = await this.orgService.resetInvite(context.user.id, req.organizationId);
+        const inviteId = await this.orgService.resetInvite(userId(), req.organizationId);
         const result = new ResetOrganizationInvitationResponse();
         result.invitationId = inviteId.id;
         return result;
     }
 
     async listOrganizationMembers(
         req: ListOrganizationMembersRequest,
-        context: HandlerContext,
+        _: HandlerContext,
     ): Promise<ListOrganizationMembersResponse> {
-        const members = await this.orgService.listMembers(context.user.id, req.organizationId);
+        const members = await this.orgService.listMembers(userId(), req.organizationId);
         //TODO pagination
         const response = new ListOrganizationMembersResponse();
         response.members = members.map((member) => this.apiConverter.toOrganizationMember(member));
@@ -140,10 +134,10 @@ export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationSe
 
     async updateOrganizationMember(
         req: UpdateOrganizationMemberRequest,
-        context: HandlerContext,
+        _: HandlerContext,
     ): Promise<UpdateOrganizationMemberResponse> {
         await this.orgService.addOrUpdateMember(
-            context.user.id,
+            userId(),
             req.organizationId,
             req.userId,
             this.apiConverter.fromOrgMemberRole(req.role),
@@ -153,27 +147,27 @@ export class OrganizationServiceAPI implements ServiceImpl<typeof OrganizationSe
 
     async deleteOrganizationMember(
         req: DeleteOrganizationMemberRequest,
-        context: HandlerContext,
+        _: HandlerContext,
     ): Promise<DeleteOrganizationMemberResponse> {
-        await this.orgService.removeOrganizationMember(context.user.id, req.organizationId, req.userId);
+        await this.orgService.removeOrganizationMember(userId(), req.organizationId, req.userId);
         return new DeleteOrganizationMemberResponse();
     }
 
     async getOrganizationSettings(
         req: GetOrganizationSettingsRequest,
-        context: HandlerContext,
+        _: HandlerContext,
     ): Promise<GetOrganizationSettingsResponse> {
-        const settings = await this.orgService.getSettings(context.user.id, req.organizationId);
+        const settings = await this.orgService.getSettings(userId(), req.organizationId);
         const response = new GetOrganizationSettingsResponse();
         response.settings = this.apiConverter.toOrganizationSettings(settings);
         return response;
     }
 
     async updateOrganizationSettings(
         req: UpdateOrganizationSettingsRequest,
-        context: HandlerContext,
+        _: HandlerContext,
     ): Promise<UpdateOrganizationSettingsResponse> {
-        await this.orgService.updateSettings(context.user.id, req.organizationId, {
+        await this.orgService.updateSettings(userId(), req.organizationId, {
             workspaceSharingDisabled: req.settings?.workspaceSharingDisabled,
             defaultWorkspaceImage: req.settings?.defaultWorkspaceImage,
         });