@gitpod/gitpod-protocol 0.1.5-sje-pacman.1 → 0.1.5-sje-kots-node-reqs.1

package/src/protocol.ts

@@ -68,13 +68,22 @@ export namespace User {
         });
         return res;
     }
-    export function getPrimaryEmail(user: User): string {
+
+    /**
+     * 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) {
-            throw new Error(`No identity with primary email for user: ${user.id}!`);
+            return undefined;
         }
 
-        return identities[0].primaryEmail!;
+        return identities[0].primaryEmail || undefined;
     }
     export function getName(user: User): string | undefined {
         const name = user.fullName || user.name;
@@ -89,6 +98,91 @@ export namespace User {
         }
         return undefined;
     }
+
+    export function hasPreferredIde(user: User) {
+        return (
+            typeof user?.additionalData?.ideSettings?.defaultIde !== "undefined" ||
+            typeof user?.additionalData?.ideSettings?.useLatestVersion !== "undefined"
+        );
+    }
+
+    export function isOnboardingUser(user: User) {
+        return !hasPreferredIde(user);
+    }
+
+    export function migrationIDESettings(user: User) {
+        if (
+            !user?.additionalData?.ideSettings ||
+            Object.keys(user.additionalData.ideSettings).length === 0 ||
+            user.additionalData.ideSettings.settingVersion === "2.0"
+        ) {
+            return;
+        }
+        const newIDESettings: IDESettings = {
+            settingVersion: "2.0",
+        };
+        const ideSettings = user.additionalData.ideSettings;
+        if (ideSettings.useDesktopIde) {
+            if (ideSettings.defaultDesktopIde === "code-desktop") {
+                newIDESettings.defaultIde = "code-desktop";
+            } else if (ideSettings.defaultDesktopIde === "code-desktop-insiders") {
+                newIDESettings.defaultIde = "code-desktop";
+                newIDESettings.useLatestVersion = true;
+            } else {
+                newIDESettings.defaultIde = ideSettings.defaultDesktopIde;
+                newIDESettings.useLatestVersion = ideSettings.useLatestVersion;
+            }
+        } else {
+            const useLatest = ideSettings.defaultIde === "code-latest";
+            newIDESettings.defaultIde = "code";
+            newIDESettings.useLatestVersion = useLatest;
+        }
+        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 {
@@ -103,9 +197,24 @@ 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;
+    // 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;
+    // 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 {
@@ -115,12 +224,20 @@ export interface EmailNotificationSettings {
 }
 
 export type IDESettings = {
+    settingVersion?: string;
     defaultIde?: string;
+    // DEPRECATED: Use defaultIde after `settingVersion: 2.0`, no more specialify desktop or browser.
     useDesktopIde?: boolean;
+    // DEPRECATED: Same with useDesktopIde.
     defaultDesktopIde?: string;
     useLatestVersion?: boolean;
 };
 
+export interface WorkspaceClasses {
+    regular: string;
+    prebuild: string;
+}
+
 export interface UserPlatform {
     uid: string;
     userAgent: string;
@@ -151,7 +268,12 @@ export interface UserFeatureSettings {
  * The values of this type MUST MATCH enum values in WorkspaceFeatureFlag from ws-manager/client/core_pb.d.ts
  * If they don't we'll break things during workspace startup.
  */
-export const WorkspaceFeatureFlags = { full_workspace_backup: undefined, fixed_resources: undefined };
+export const WorkspaceFeatureFlags = {
+    full_workspace_backup: undefined,
+    fixed_resources: undefined,
+    persistent_volume_claim: undefined,
+    protected_secrets: undefined,
+};
 export type NamedWorkspaceFeatureFlag = keyof typeof WorkspaceFeatureFlags;
 
 export interface EnvVarWithValue {
@@ -178,6 +300,45 @@ export interface UserEnvVar extends UserEnvVarValue {
 }
 
 export namespace UserEnvVar {
+    /**
+     * @param variable
+     * @returns Either a string containing an error message or undefined.
+     */
+    export function validate(variable: UserEnvVarValue): string | undefined {
+        const name = variable.name;
+        const pattern = variable.repositoryPattern;
+        if (name.trim() === "") {
+            return "Name must not be empty.";
+        }
+        if (name.length > 255) {
+            return "Name too long. Maximum name length is 255 characters.";
+        }
+        if (!/^[a-zA-Z_]+[a-zA-Z0-9_]*$/.test(name)) {
+            return "Name must match /^[a-zA-Z_]+[a-zA-Z0-9_]*$/.";
+        }
+        if (variable.value.trim() === "") {
+            return "Value must not be empty.";
+        }
+        if (variable.value.length > 32767) {
+            return "Value too long. Maximum value length is 32767 characters.";
+        }
+        if (pattern.trim() === "") {
+            return "Scope must not be empty.";
+        }
+        const split = pattern.split("/");
+        if (split.length < 2) {
+            return "A scope must use the form 'organization/repo'.";
+        }
+        for (const name of split) {
+            if (name !== "*") {
+                if (!/^[a-zA-Z0-9_\-.\*]+$/.test(name)) {
+                    return "Invalid scope segment. Only ASCII characters, numbers, -, _, . or * are allowed.";
+                }
+            }
+        }
+        return undefined;
+    }
+
     // DEPRECATED: Use ProjectEnvVar instead of repositoryPattern - https://github.com/gitpod-com/gitpod/issues/5322
     export function normalizeRepoPattern(pattern: string) {
         return pattern.toLocaleLowerCase();
@@ -263,6 +424,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;
@@ -395,6 +618,13 @@ export interface Snapshot {
     message?: string;
 }
 
+export interface VolumeSnapshot {
+    id: string;
+    workspaceId: string;
+    creationTime: string;
+    volumeHandle: string;
+}
+
 export type SnapshotState = "pending" | "available" | "error";
 
 export interface LayoutData {
@@ -464,7 +694,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 {
@@ -532,6 +762,20 @@ export interface VSCodeConfig {
     extensions?: string[];
 }
 
+export interface JetBrainsConfig {
+    intellij?: JetBrainsProductConfig;
+    goland?: JetBrainsProductConfig;
+    pycharm?: JetBrainsProductConfig;
+    phpstorm?: JetBrainsProductConfig;
+}
+export interface JetBrainsProductConfig {
+    prebuilds?: JetBrainsPrebuilds;
+    vmoptions?: string;
+}
+export interface JetBrainsPrebuilds {
+    version?: "stable" | "latest" | "both";
+}
+
 export interface RepositoryCloneInformation {
     url: string;
     checkoutLocation?: string;
@@ -548,6 +792,7 @@ export interface WorkspaceConfig {
     gitConfig?: { [config: string]: string };
     github?: GithubAppConfig;
     vscode?: VSCodeConfig;
+    jetbrains?: JetBrainsConfig;
 
     /** deprecated. Enabled by default **/
     experimentalNetwork?: boolean;
@@ -634,13 +879,16 @@ export interface PrebuiltWorkspace {
     buildWorkspaceId: string;
     creationTime: string;
     state: PrebuiltWorkspaceState;
+    statusVersion: number;
     error?: string;
     snapshot?: string;
 }
 
 export namespace PrebuiltWorkspace {
     export function isDone(pws: PrebuiltWorkspace) {
-        return pws.state === "available" || pws.state === "timeout" || pws.state === "aborted";
+        return (
+            pws.state === "available" || pws.state === "timeout" || pws.state === "aborted" || pws.state === "failed"
+        );
     }
 
     export function isAvailable(pws: PrebuiltWorkspace) {
@@ -764,6 +1012,7 @@ export namespace ExternalImageConfigFile {
 
 export interface WorkspaceContext {
     title: string;
+    ref?: string;
     /** This contains the URL portion of the contextURL (which might contain other modifiers as well). It's optional because it's not set for older workspaces. */
     normalizedContextURL?: string;
     forceCreateNewWorkspace?: boolean;
@@ -1015,6 +1264,8 @@ export interface Repository {
     owner: string;
     name: string;
     cloneUrl: string;
+    /* Optional kind to differentiate between repositories of orgs/groups/projects and personal repos. */
+    repoKind?: string;
     description?: string;
     avatarUrl?: string;
     webUrl?: string;
@@ -1143,12 +1394,6 @@ export interface AuthProviderInfo {
     };
 }
 
-export namespace AuthProviderInfo {
-    export function isGitHubEnterprise(info?: AuthProviderInfo): boolean {
-        return !!info && info.authProviderType === "GitHub" && info.host !== "github.com";
-    }
-}
-
 export interface AuthProviderEntry {
     readonly id: string;
     readonly type: AuthProviderEntry.Type;

package/src/team-subscription-protocol.ts

@@ -33,6 +33,30 @@ export namespace TeamSubscription {
     };
 }
 
+export interface TeamSubscription2 {
+    id: string;
+    teamId: string;
+    planId: string;
+    startDate: string;
+    endDate?: string;
+    quantity: number;
+    /** The Chargebee subscription id */
+    paymentReference: string;
+    cancellationDate?: string;
+    excludeFromMoreResources: boolean;
+}
+
+export namespace TeamSubscription2 {
+    export const create = (ts2: Omit<TeamSubscription2, "id">): TeamSubscription2 => {
+        const withId = ts2 as TeamSubscription2;
+        withId.id = uuidv4();
+        return withId;
+    };
+    export const isActive = (ts2: TeamSubscription2, date: string): boolean => {
+        return ts2.startDate <= date && (ts2.endDate === undefined || date < ts2.endDate);
+    };
+}
+
 /**
  * A slot represents one unit of a TeamSubscription that gets assigned to one user at a time
  */

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;
@@ -14,6 +15,8 @@ export interface ProjectConfig {
 
 export interface ProjectSettings {
     useIncrementalPrebuilds?: boolean;
+    usePersistentVolumeClaim?: boolean;
+    keepOutdatedPrebuildsRunning?: boolean;
 }
 
 export interface Project {
@@ -69,6 +72,11 @@ export namespace Project {
 
 export type PartialProject = DeepPartial<Project> & Pick<Project, "id">;
 
+export interface ProjectUsage {
+    lastWebhookReceived: string;
+    lastWorkspaceStart: string;
+}
+
 export interface PrebuildWithStatus {
     info: PrebuildInfo;
     status: PrebuiltWorkspaceState;
@@ -145,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,146 @@
+/**
+ * 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;
+
+    // "standard" or "XL"
+    workspaceClass: string;
+
+    // When the workspace started
+    startTime: string;
+
+    // When the workspace ended
+    endTime: string;
+
+    // The credits used for this session
+    credits: number;
+
+    // TODO - maybe
+    projectId?: string;
+}
+
+export type BillableWorkspaceType = WorkspaceType;
+
+export const billableSessionDummyData: BillableSession[] = [
+    {
+        attributionId: "some-attribution-id",
+        userId: "prebuild",
+        teamId: "prebuild",
+        instanceId: "some-instance-id",
+        workspaceId: "some-workspace-id",
+        workspaceType: "prebuild",
+        workspaceClass: "XL",
+        startTime: new Date(Date.now() + -3 * 24 * 3600 * 1000).toISOString(), // 3 days ago
+        endTime: new Date().toISOString(),
+        credits: 320,
+        projectId: "project-123",
+    },
+    {
+        attributionId: "some-attribution-id2",
+        userId: "some-user",
+        teamId: "some-team",
+        instanceId: "some-instance-id2",
+        workspaceId: "some-workspace-id2",
+        workspaceType: "regular",
+        workspaceClass: "standard",
+        startTime: new Date(Date.now() + -5 * 24 * 3600 * 1000).toISOString(),
+        endTime: new Date().toISOString(),
+        credits: 130,
+        projectId: "project-123",
+    },
+    {
+        attributionId: "some-attribution-id3",
+        userId: "some-other-user",
+        teamId: "some-other-team",
+        instanceId: "some-instance-id3",
+        workspaceId: "some-workspace-id3",
+        workspaceType: "regular",
+        workspaceClass: "XL",
+        startTime: new Date(Date.now() + -5 * 24 * 3600 * 1000).toISOString(),
+        endTime: new Date(Date.now() + -4 * 24 * 3600 * 1000).toISOString(),
+        credits: 150,
+        projectId: "project-134",
+    },
+    {
+        attributionId: "some-attribution-id4",
+        userId: "some-other-user2",
+        teamId: "some-other-team2",
+        instanceId: "some-instance-id4",
+        workspaceId: "some-workspace-id4",
+        workspaceType: "regular",
+        workspaceClass: "standard",
+        startTime: new Date(Date.now() + -10 * 24 * 3600 * 1000).toISOString(),
+        endTime: new Date(Date.now() + -9 * 24 * 3600 * 1000).toISOString(),
+        credits: 330,
+        projectId: "project-137",
+    },
+    {
+        attributionId: "some-attribution-id5",
+        userId: "some-other-user3",
+        teamId: "some-other-team3",
+        instanceId: "some-instance-id5",
+        workspaceId: "some-workspace-id5",
+        workspaceType: "regular",
+        workspaceClass: "XL",
+        startTime: new Date(Date.now() + -2 * 24 * 3600 * 1000).toISOString(),
+        endTime: new Date().toISOString(),
+        credits: 222,
+        projectId: "project-138",
+    },
+    {
+        attributionId: "some-attribution-id6",
+        userId: "some-other-user4",
+        teamId: "some-other-team4",
+        instanceId: "some-instance-id6",
+        workspaceId: "some-workspace-id3",
+        workspaceType: "regular",
+        workspaceClass: "XL",
+        startTime: new Date(Date.now() + -7 * 24 * 3600 * 1000).toISOString(),
+        endTime: new Date(Date.now() + -6 * 24 * 3600 * 1000).toISOString(),
+        credits: 300,
+        projectId: "project-134",
+    },
+    {
+        attributionId: "some-attribution-id8",
+        userId: "some-other-user5",
+        teamId: "some-other-team5",
+        instanceId: "some-instance-id8",
+        workspaceId: "some-workspace-id3",
+        workspaceType: "regular",
+        workspaceClass: "standard",
+        startTime: new Date(Date.now() + -1 * 24 * 3600 * 1000).toISOString(),
+        endTime: new Date().toISOString(),
+        credits: 100,
+        projectId: "project-567",
+    },
+    {
+        attributionId: "some-attribution-id7",
+        userId: "prebuild",
+        teamId: "some-other-team7",
+        instanceId: "some-instance-id7",
+        workspaceId: "some-workspace-id7",
+        workspaceType: "prebuild",
+        workspaceClass: "XL",
+        startTime: new Date(Date.now() + -1 * 24 * 3600 * 1000).toISOString(),
+        endTime: new Date().toISOString(),
+        credits: 200,
+        projectId: "project-345",
+    },
+];

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;
+    }
+}