@gitpod/gitpod-protocol 0.1.5-pavel-10259-1.39 → 0.1.5-pavel-fixlog.0

package/src/protocol.ts

@@ -45,6 +45,9 @@ export interface User {
     markedDeleted?: boolean;
 
     additionalData?: AdditionalUserData;
+
+    // Identifies an explicit team or user ID to which all the user's workspace usage should be attributed to (e.g. for billing purposes)
+    usageAttributionId?: string;
 }
 
 export namespace User {
@@ -70,11 +73,14 @@ export namespace User {
     }
 
     /**
-     * Tries to return the primaryEmail of the first identity this user signed up with.
+     * Returns the stored email or if it doesn't exist returns the primaryEmail of the first identity this user signed up with.
      * @param user
      * @returns A primaryEmail, or undefined if there is none.
      */
     export function getPrimaryEmail(user: User): string | undefined {
+        if (user.additionalData?.profile?.emailAddress) {
+            return user.additionalData?.profile?.emailAddress;
+        }
         const identities = user.identities.filter((i) => !!i.primaryEmail);
         if (identities.length <= 0) {
             return undefined;
@@ -136,6 +142,50 @@ export namespace User {
         }
         user.additionalData.ideSettings = newIDESettings;
     }
+
+    export function getProfile(user: User): Profile {
+        return {
+            name: User.getName(user!) || "",
+            email: User.getPrimaryEmail(user!) || "",
+            company: user?.additionalData?.profile?.companyName,
+            avatarURL: user?.avatarUrl,
+        };
+    }
+
+    export function setProfile(user: User, profile: Profile): User {
+        user.fullName = profile.name;
+        user.avatarUrl = profile.avatarURL;
+
+        if (!user.additionalData) {
+            user.additionalData = {};
+        }
+        if (!user.additionalData.profile) {
+            user.additionalData.profile = {};
+        }
+        user.additionalData.profile.emailAddress = profile.email;
+        user.additionalData.profile.companyName = profile.company;
+        user.additionalData.profile.lastUpdatedDetailsNudge = new Date().toISOString();
+
+        return user;
+    }
+
+    // The actual Profile of a User
+    export interface Profile {
+        name: string;
+        email: string;
+        company?: string;
+        avatarURL?: string;
+    }
+    export namespace Profile {
+        export function hasChanges(before: Profile, after: Profile) {
+            return (
+                before.name !== after.name ||
+                before.email !== after.email ||
+                before.company !== after.company ||
+                before.avatarURL !== after.avatarURL
+            );
+        }
+    }
 }
 
 export interface AdditionalUserData {
@@ -150,9 +200,22 @@ export interface AdditionalUserData {
     oauthClientsApproved?: { [key: string]: string };
     // to remember GH Orgs the user installed/updated the GH App for
     knownGitHubOrgs?: string[];
-
     // Git clone URL pointing to the user's dotfile repo
     dotfileRepo?: string;
+    // preferred workspace classes
+    workspaceClasses?: WorkspaceClasses;
+    // additional user profile data
+    profile?: ProfileDetails;
+}
+
+// The format in which we store User Profiles in
+export interface ProfileDetails {
+    // when was the last time the user updated their profile information or has been nudged to do so.
+    lastUpdatedDetailsNudge?: string;
+    // the user's company name
+    companyName?: string;
+    // the user's email
+    emailAddress?: string;
 }
 
 export interface EmailNotificationSettings {
@@ -171,6 +234,11 @@ export type IDESettings = {
     useLatestVersion?: boolean;
 };
 
+export interface WorkspaceClasses {
+    regular: string;
+    prebuild: string;
+}
+
 export interface UserPlatform {
     uid: string;
     userAgent: string;
@@ -203,8 +271,9 @@ export interface UserFeatureSettings {
  */
 export const WorkspaceFeatureFlags = {
     full_workspace_backup: undefined,
-    fixed_resources: undefined,
     persistent_volume_claim: undefined,
+    protected_secrets: undefined,
+    workspace_class_limiting: undefined,
 };
 export type NamedWorkspaceFeatureFlag = keyof typeof WorkspaceFeatureFlags;
 
@@ -356,6 +425,68 @@ export namespace UserEnvVar {
     }
 }
 
+export interface SSHPublicKeyValue {
+    name: string;
+    key: string;
+}
+export interface UserSSHPublicKey extends SSHPublicKeyValue {
+    id: string;
+    key: string;
+    userId: string;
+    fingerprint: string;
+    creationTime: string;
+    lastUsedTime?: string;
+}
+
+export type UserSSHPublicKeyValue = Omit<UserSSHPublicKey, "key" | "userId">;
+
+export namespace SSHPublicKeyValue {
+    export function validate(value: SSHPublicKeyValue): string | undefined {
+        if (value.name.length === 0) {
+            return "Title must not be empty.";
+        }
+        if (value.name.length > 255) {
+            return "Title too long. Maximum value length is 255 characters.";
+        }
+        if (value.key.length === 0) {
+            return "Key must not be empty.";
+        }
+        try {
+            getData(value);
+        } catch (e) {
+            return "Key is invalid. You must supply a key in OpenSSH public key format.";
+        }
+        return;
+    }
+
+    export function getData(value: SSHPublicKeyValue) {
+        // Begins with 'ssh-rsa', 'ecdsa-sha2-nistp256', 'ecdsa-sha2-nistp384', 'ecdsa-sha2-nistp521', 'ssh-ed25519', 'sk-ecdsa-sha2-nistp256@openssh.com', or 'sk-ssh-ed25519@openssh.com'.
+        const regex =
+            /^(?<type>ssh-rsa|ecdsa-sha2-nistp256|ecdsa-sha2-nistp384|ecdsa-sha2-nistp521|ssh-ed25519|sk-ecdsa-sha2-nistp256@openssh\.com|sk-ssh-ed25519@openssh\.com) (?<key>.*?)( (?<email>.*?))?$/;
+        const resultGroup = regex.exec(value.key.trim());
+        if (!resultGroup) {
+            throw new Error("Key is invalid.");
+        }
+        return {
+            type: resultGroup.groups?.["type"] as string,
+            key: resultGroup.groups?.["key"] as string,
+            email: resultGroup.groups?.["email"] || undefined,
+        };
+    }
+
+    export function getFingerprint(value: SSHPublicKeyValue) {
+        const data = getData(value);
+        let buf = Buffer.from(data.key, "base64");
+        // gitlab style
+        // const hash = createHash("md5").update(buf).digest("hex");
+        // github style
+        const hash = createHash("sha256").update(buf).digest("base64");
+        return hash;
+    }
+
+    export const MAXIMUM_KEY_LENGTH = 5;
+}
+
 export interface GitpodToken {
     /** Hash value (SHA256) of the token (primary key). */
     tokenHash: string;
@@ -564,7 +695,7 @@ export interface Workspace {
 
 export type WorkspaceSoftDeletion = "user" | "gc";
 
-export type WorkspaceType = "regular" | "prebuild" | "probe";
+export type WorkspaceType = "regular" | "prebuild" | "probe"; // TODO(gpl) Removed prove here
 
 export namespace Workspace {
     export function getFullRepositoryName(ws: Workspace): string | undefined {
@@ -640,6 +771,7 @@ export interface JetBrainsConfig {
 }
 export interface JetBrainsProductConfig {
     prebuilds?: JetBrainsPrebuilds;
+    vmoptions?: string;
 }
 export interface JetBrainsPrebuilds {
     version?: "stable" | "latest" | "both";
@@ -1350,3 +1482,11 @@ export interface Terms {
     readonly content: string;
     readonly formElements?: object;
 }
+
+export interface CostCenter {
+    readonly id: string;
+    /**
+     * Unit: credits
+     */
+    spendingLimit: number;
+}

package/src/team-subscription-protocol.ts

@@ -55,6 +55,9 @@ export namespace TeamSubscription2 {
     export const isActive = (ts2: TeamSubscription2, date: string): boolean => {
         return ts2.startDate <= date && (ts2.endDate === undefined || date < ts2.endDate);
     };
+    export function isCancelled(s: TeamSubscription2, date: string): boolean {
+        return (!!s.cancellationDate && s.cancellationDate < date) || (!!s.endDate && s.endDate < date); // This edge case is meant to handle bad data: If for whatever reason cancellationDate has not been set: treat endDate as such
+    }
 }
 
 /**

package/src/teams-projects-protocol.ts

@@ -7,6 +7,7 @@
 import { PrebuiltWorkspaceState } from "./protocol";
 import { v4 as uuidv4 } from "uuid";
 import { DeepPartial } from "./util/deep-partial";
+import { WebhookEvent } from "./webhook-event";
 
 export interface ProjectConfig {
     ".gitpod.yml": string;
@@ -15,6 +16,7 @@ export interface ProjectConfig {
 export interface ProjectSettings {
     useIncrementalPrebuilds?: boolean;
     usePersistentVolumeClaim?: boolean;
+    keepOutdatedPrebuildsRunning?: boolean;
 }
 
 export interface Project {
@@ -151,3 +153,15 @@ export interface TeamMembershipInvite {
     /** This is a flag that triggers the HARD DELETION of this entity */
     deleted?: boolean;
 }
+
+export interface PrebuildEvent {
+    id: string;
+    creationTime: string;
+    status: WebhookEvent.Status | WebhookEvent.PrebuildStatus;
+    message?: string;
+    prebuildId?: string;
+    projectId?: string;
+    cloneUrl?: string;
+    branch?: string;
+    commit?: string;
+}

package/src/usage.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2022 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License-AGPL.txt in the project root for license information.
+ */
+
+import { WorkspaceType } from "./protocol";
+
+export interface BillableSession {
+    // The id of the one paying the bill
+    attributionId: string;
+
+    // Relevant for workspace type. When prebuild, shows "prebuild"
+    userId?: string;
+    teamId?: string;
+
+    instanceId: string;
+
+    workspaceId: string;
+
+    workspaceType: BillableWorkspaceType;
+
+    workspaceClass: string;
+
+    // When the workspace started
+    startTime: string;
+
+    // When the workspace ended. Not set when the workspace is still running.
+    endTime?: string;
+
+    // The credits used for this session
+    credits: number;
+
+    // TODO - maybe
+    projectId?: string;
+}
+
+export interface BillableSessionRequest {
+    attributionId: string;
+    startedTimeOrder: SortOrder;
+    from?: number;
+    to?: number;
+}
+
+export type BillableWorkspaceType = WorkspaceType;
+
+export enum SortOrder {
+    Descending = 0,
+    Ascending = 1,
+}

package/src/util/debug-app.ts

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2021 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License-AGPL.txt in the project root for license information.
+ */
+
+import * as http from "http";
+import * as express from "express";
+import { injectable, postConstruct } from "inversify";
+import { log, LogrusLogLevel } from "./logging";
+
+export interface SetLogLevelRequest {
+    level: LogrusLogLevel;
+}
+export namespace SetLogLevelRequest {
+    export function is(o: any): o is SetLogLevelRequest {
+        return typeof o === "object" && "level" in o;
+    }
+}
+
+@injectable()
+export class DebugApp {
+    protected _app: express.Application;
+    protected httpServer: http.Server | undefined = undefined;
+
+    @postConstruct()
+    public ctor() {
+        this._app = this.create();
+    }
+
+    create(): express.Application {
+        const app = express();
+
+        app.use(express.json());
+        app.use(express.urlencoded({ extended: true }));
+
+        app.post("/debug/logging", (req, res) => {
+            try {
+                const levelRequest = req.body;
+                if (!SetLogLevelRequest.is(levelRequest)) {
+                    res.status(400).end("not a SetLogLevelRequest");
+                    return;
+                }
+
+                const newLogLevel = levelRequest.level;
+                log.setLogLevel(newLogLevel);
+                log.info("set log level", { newLogLevel });
+                res.status(200).end(JSON.stringify(levelRequest));
+            } catch (err) {
+                res.status(500).end(err);
+            }
+        });
+        return app;
+    }
+
+    public start(port: number = 6060) {
+        this.httpServer = this._app.listen(port, "localhost", () => {
+            log.info(`debug server listening on port: ${port}`);
+        });
+    }
+
+    public async stop() {
+        const server = this.httpServer;
+        if (!server) {
+            return;
+        }
+        return new Promise<void>((resolve) =>
+            server.close((err: any) => {
+                if (err) {
+                    log.warn(`error while closing http server`, { err });
+                }
+                this.httpServer = undefined;
+                resolve();
+            }),
+        );
+    }
+
+    public get app(): express.Application {
+        return this._app;
+    }
+}

package/src/util/gitpod-host-url.ts

@@ -85,6 +85,10 @@ export class GitpodHostUrl {
         return this.with((url) => ({ protocol: url.protocol === "https:" ? "wss:" : "ws:" }));
     }
 
+    asWorkspacePage(): GitpodHostUrl {
+        return this.with((url) => ({ pathname: "/workspaces" }));
+    }
+
     asDashboard(): GitpodHostUrl {
         return this.with((url) => ({ pathname: "/" }));
     }
@@ -171,4 +175,21 @@ export class GitpodHostUrl {
     asApiLogout(): GitpodHostUrl {
         return this.withApi((url) => ({ pathname: "/logout/" }));
     }
+
+    asIDEProxy(): GitpodHostUrl {
+        const hostSegments = this.url.host.split(".");
+        if (hostSegments[0] === "ide") {
+            return this;
+        }
+        return this.with((url) => ({ host: "ide." + url.host }));
+    }
+
+    asIDEMetrics(): GitpodHostUrl {
+        let newUrl: GitpodHostUrl = this;
+        const hostSegments = this.url.host.split(".");
+        if (hostSegments[0] !== "ide") {
+            newUrl = newUrl.asIDEProxy();
+        }
+        return newUrl.with((url) => ({ pathname: "/metrics-api" }));
+    }
 }

package/src/util/grpc.ts

@@ -4,6 +4,9 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
+import * as grpc from "@grpc/grpc-js";
+import { Status } from "@grpc/grpc-js/build/src/constants";
+
 export const defaultGRPCOptions = {
     "grpc.keepalive_timeout_ms": 10000,
     "grpc.keepalive_time_ms": 60000,
@@ -13,3 +16,89 @@ export const defaultGRPCOptions = {
     "grpc.max_reconnect_backoff_ms": 5000,
     "grpc.max_receive_message_length": 1024 * 1024 * 16,
 };
+
+export type GrpcMethodType = "unary" | "client_stream" | "server_stream" | "bidi_stream";
+
+export interface IGrpcCallMetricsLabels {
+    service: string;
+    method: string;
+    type: GrpcMethodType;
+}
+
+export interface IGrpcCallMetricsLabelsWithCode extends IGrpcCallMetricsLabels {
+    code: string;
+}
+
+export const IClientCallMetrics = Symbol("IClientCallMetrics");
+
+export interface IClientCallMetrics {
+    started(labels: IGrpcCallMetricsLabels): void;
+    sent(labels: IGrpcCallMetricsLabels): void;
+    received(labels: IGrpcCallMetricsLabels): void;
+    handled(labels: IGrpcCallMetricsLabelsWithCode): void;
+}
+
+export function getGrpcMethodType(requestStream: boolean, responseStream: boolean): GrpcMethodType {
+    if (requestStream) {
+        if (responseStream) {
+            return "bidi_stream";
+        } else {
+            return "client_stream";
+        }
+    } else {
+        if (responseStream) {
+            return "server_stream";
+        } else {
+            return "unary";
+        }
+    }
+}
+
+export function createClientCallMetricsInterceptor(metrics: IClientCallMetrics): grpc.Interceptor {
+    return (options, nextCall): grpc.InterceptingCall => {
+        const methodDef = options.method_definition;
+        const method = methodDef.path.substring(methodDef.path.lastIndexOf("/") + 1);
+        const service = methodDef.path.substring(1, methodDef.path.length - method.length - 1);
+        const labels = {
+            service,
+            method,
+            type: getGrpcMethodType(options.method_definition.requestStream, options.method_definition.responseStream),
+        };
+        const requester = new grpc.RequesterBuilder()
+            .withStart((metadata, listener, next) => {
+                const newListener = new grpc.ListenerBuilder()
+                    .withOnReceiveStatus((status, next) => {
+                        try {
+                            metrics.handled({
+                                ...labels,
+                                code: Status[status.code],
+                            });
+                        } finally {
+                            next(status);
+                        }
+                    })
+                    .withOnReceiveMessage((message, next) => {
+                        try {
+                            metrics.received(labels);
+                        } finally {
+                            next(message);
+                        }
+                    })
+                    .build();
+                try {
+                    metrics.started(labels);
+                } finally {
+                    next(metadata, newListener);
+                }
+            })
+            .withSendMessage((message, next) => {
+                try {
+                    metrics.sent(labels);
+                } finally {
+                    next(message);
+                }
+            })
+            .build();
+        return new grpc.InterceptingCall(nextCall(options), requester);
+    };
+}

package/src/util/logging.ts

@@ -6,6 +6,7 @@
 
 const inspect: (object: any) => string = require("util").inspect; // undefined in frontend
 
+let plainLogging: boolean = false; // set to true during development to get non JSON output
 let jsonLogging: boolean = false;
 let component: string | undefined;
 let version: string | undefined;
@@ -309,7 +310,7 @@ function makeLogItem(
     }
 
     const payload: any = payloadArgs.length == 0 ? undefined : payloadArgs.length == 1 ? payloadArgs[0] : payloadArgs;
-    const logItem: any = {
+    const logItem = {
         // undefined fields get eliminated in JSON.stringify()
         ...reportedErrorEvent,
         component,
@@ -321,11 +322,19 @@ function makeLogItem(
         payload,
         loggedViaConsole: calledViaConsole ? true : undefined,
     };
+    if (plainLogging) {
+        return `[${logItem.severity}] [${logItem.component}] ${logItem.message}
+            ${JSON.stringify(payload || "", undefined, "              ")}
+            ${error || ""}
+        `.trim();
+    }
     let result: string = stringifyLogItem(logItem);
 
     if (result.length > maxAllowedLogItemLength && payload !== undefined) {
         delete logItem.payload;
-        logItem.payloadStub = `Payload stripped as log item was longer than ${maxAllowedLogItemLength} characters`;
+        (<any>(
+            logItem
+        )).payloadStub = `Payload stripped as log item was longer than ${maxAllowedLogItemLength} characters`;
 
         result = stringifyLogItem(logItem);
 

package/src/util/timeutil.ts

@@ -47,6 +47,12 @@ export const orderAsc = (d1: string, d2: string): number => liftDate(d1, d2, (d1
 export const liftDate1 = <T>(d1: string, f: (d1: Date) => T): T => f(new Date(d1));
 export const liftDate = <T>(d1: string, d2: string, f: (d1: Date, d2: Date) => T): T => f(new Date(d1), new Date(d2));
 
+export function hoursBefore(date: string, hours: number): string {
+    const result = new Date(date);
+    result.setHours(result.getHours() - hours);
+    return result.toISOString();
+}
+
 export function hoursLater(date: string, hours: number): string {
     const result = new Date(date);
     result.setHours(result.getHours() + hours);

package/src/webhook-event.ts

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) 2022 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License-AGPL.txt in the project root for license information.
+ */
+
+export interface WebhookEvent {
+    id: string;
+    creationTime: string;
+    type: "push" | string;
+
+    /**
+     * Typically the webhook installer is referenced here.
+     */
+    authorizedUserId?: string;
+
+    /**
+     * webhook event's payload
+     */
+    rawEvent: string;
+
+    /**
+     * The general status of the received webhook event.
+     */
+    status: WebhookEvent.Status;
+
+    /**
+     * Optional message to help understand errors with handling events.
+     */
+    message?: string;
+
+    /**
+     * If the webhook event is considered to trigger a prebuild, the `prebuildStatus`
+     * contains a more specific status.
+     */
+    prebuildStatus?: WebhookEvent.PrebuildStatus;
+
+    /**
+     * If `prebuildStatus` is `prebuild_triggered` this points to a prebuild.
+     */
+    prebuildId?: string;
+
+    projectId?: string;
+
+    cloneUrl?: string;
+
+    branch?: string;
+
+    commit?: string;
+}
+
+export namespace WebhookEvent {
+    export type Status = "received" | "dismissed_unauthorized" | "ignored" | "processed";
+    export type PrebuildStatus = "ignored_unconfigured" | "prebuild_trigger_failed" | "prebuild_triggered";
+}

package/src/workspace-class.ts

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) 2022 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License-AGPL.txt in the project root for license information.
+ */
+
+export interface SupportedWorkspaceClass {
+    id: string;
+    category: string;
+    displayName: string;
+    description: string;
+    powerups: number;
+    isDefault: boolean;
+}

package/src/workspace-cluster.ts

@@ -56,12 +56,10 @@ export type WorkspaceManagerConnectionInfo = Pick<WorkspaceCluster, "name" | "ur
 export type AdmissionConstraint =
     | AdmissionConstraintFeaturePreview
     | AdmissionConstraintHasPermission
-    | AdmissionConstraintHasUserLevel
-    | AdmissionConstraintHasMoreResources;
+    | AdmissionConstraintHasClass;
 export type AdmissionConstraintFeaturePreview = { type: "has-feature-preview" };
 export type AdmissionConstraintHasPermission = { type: "has-permission"; permission: PermissionName };
-export type AdmissionConstraintHasUserLevel = { type: "has-user-level"; level: string };
-export type AdmissionConstraintHasMoreResources = { type: "has-more-resources" };
+export type AdmissionConstraintHasClass = { type: "has-class"; id: string; displayName: string };
 
 export namespace AdmissionConstraint {
     export function is(o: any): o is AdmissionConstraint {

package/src/workspace-instance.ts

@@ -62,10 +62,21 @@ export interface WorkspaceInstance {
      * resources that are provided to the workspace.
      */
     workspaceClass?: string;
+
+    /**
+     * Identifies the team or user to which this instance's runtime should be attributed to
+     * (e.g. for usage analytics or billing purposes).
+     */
+    usageAttributionId?: string;
 }
 
 // WorkspaceInstanceStatus describes the current state of a workspace instance
 export interface WorkspaceInstanceStatus {
+    // version is the current version of the workspace instance status
+    // Note: consider this value opague. The only guarantee given is that it imposes
+    //       a partial order on status updates, i.e. a.version > b.version -> a newer than b.
+    version?: number;
+
     // phase describes a high-level state of the workspace instance
     phase: WorkspaceInstancePhase;