@gitpod/gitpod-protocol 0.1.5-se-playground.14 → 0.1.5-se-usage-view.3

package/src/protocol.ts

@@ -45,6 +45,15 @@ 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;
+
+    // The last time this user got verified somehow. The user is not verified if this is empty.
+    lastVerificationTime?: string;
+
+    // The phone number used for the last phone verification.
+    verificationPhoneNumber?: string;
 }
 
 export namespace User {
@@ -70,11 +79,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 +148,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 {
@@ -152,8 +208,34 @@ export interface AdditionalUserData {
     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;
+}
+export namespace AdditionalUserData {
+    export function set(user: User, partialData: Partial<AdditionalUserData>): User {
+        if (!user.additionalData) {
+            user.additionalData = {
+                ...partialData,
+            };
+        } else {
+            user.additionalData = {
+                ...user.additionalData,
+                ...partialData,
+            };
+        }
+        return user;
+    }
+}
+// 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 {
@@ -172,6 +254,11 @@ export type IDESettings = {
     useLatestVersion?: boolean;
 };
 
+export interface WorkspaceClasses {
+    regular: string;
+    prebuild: string;
+}
+
 export interface UserPlatform {
     uid: string;
     userAgent: string;
@@ -204,8 +291,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;
 
@@ -357,6 +445,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;
@@ -565,7 +715,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 {
@@ -1352,3 +1502,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;
@@ -152,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,128 @@
+/**
+ * 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 { User, 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 ExtendedBillableSession extends BillableSession {
+    contextURL?: string;
+    user?: Pick<User.Profile, "name" | "avatarURL">;
+}
+
+/**
+ * This is a paginated request
+ */
+export interface ListBilledUsageRequest {
+    attributionId: string;
+    fromDate?: number;
+    toDate?: number;
+    perPage: number;
+    page: number;
+}
+
+export interface ListBilledUsageResponse {
+    sessions: ExtendedBillableSession[];
+    totalCreditsUsed: number;
+    totalPages: number;
+    totalSessions: number;
+    perPage: number;
+    page: number;
+}
+
+export type BillableWorkspaceType = WorkspaceType;
+
+// types below are copied over from components/usage-api/typescript/src/usage/v1/usage_pb.d.ts
+
+export interface ListUsageRequest {
+    attributionId: string;
+    from?: number;
+    to?: number;
+    order: Ordering;
+    pagination?: PaginationRequest;
+}
+
+export enum Ordering {
+    ORDERING_DESCENDING = 0,
+    ORDERING_ASCENDING = 1,
+}
+
+export interface PaginationRequest {
+    perPage: number;
+    page: number;
+}
+
+export interface ListUsageResponse {
+    usageEntriesList: Usage[];
+    pagination?: PaginationResponse;
+    creditBalanceAtStart: number;
+    creditBalanceAtEnd: number;
+}
+
+export interface PaginationResponse {
+    perPage: number;
+    totalPages: number;
+    total: number;
+    page: number;
+}
+
+export type UsageKind = "workspaceinstance" | "invoice";
+export interface Usage {
+    id: string;
+    attributionId: string;
+    description: string;
+    credits: number;
+    effectiveTime?: number;
+    kind: UsageKind;
+    workspaceInstanceId: string;
+    draft: boolean;
+    metadata: WorkspaceInstanceUsageData | InvoiceUsageData;
+}
+
+// the equivalent golang shape is maintained in `/workspace/gitpod/`components/usage/pkg/db/usage.go`
+export interface WorkspaceInstanceUsageData {
+    workspaceId: string;
+    workspaceType: WorkspaceType;
+    workspaceClass: string;
+    contextURL: string;
+    startTime: string;
+    endTime?: string;
+    userName: string;
+    userAvatarURL: string;
+}
+
+export interface InvoiceUsageData {
+    invoiceId: string;
+    startDate: string;
+    endDate: string;
+}

package/src/util/garbage-collected-cache.ts

@@ -37,6 +37,11 @@ export class GarbageCollectedCache<T> {
         if (!entry) {
             return undefined;
         }
+        // Still valid?
+        if (entry.expiryDate < Date.now()) {
+            this.store.delete(entry.key);
+            return undefined;
+        }
         return entry.value;
     }
 

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.spec.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { suite, test } from "mocha-typescript";
+import { log } from "./logging";
+
+@suite
+class TestLogging {
+    @test public async testLogInfo_output() {
+        const testObj = {
+            null: null,
+            undefined: undefined,
+            empty: "",
+            foo: "bar",
+            number: 0,
+        };
+        log.info("info logging test", testObj);
+    }
+}
+module.exports = new TestLogging();

package/src/util/timeutil.spec.ts

@@ -7,10 +7,16 @@
 import * as chai from "chai";
 const expect = chai.expect;
 import { suite, test } from "mocha-typescript";
-import { oneMonthLater } from "./timeutil";
+import { daysBefore, hoursBefore, oneMonthLater } from "./timeutil";
 
 @suite()
 export class TimeutilSpec {
+    @test
+    testDaysBefore() {
+        const now = new Date().toISOString();
+        expect(daysBefore(now, 2)).to.be.eq(hoursBefore(now, 48));
+    }
+
     @test
     testTimeutil() {
         // targeting a 1st, 1th of Jan => 1st of Feb

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 daysBefore(date: string, days: number): string {
+    const result = new Date(date);
+    result.setDate(result.getDate() - days);
+    return result.toISOString();
+}
+
 export function hoursBefore(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;
+    isSelected: 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 {