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

package/src/util/generate-workspace-id.spec.ts

@@ -14,7 +14,7 @@ const expect = chai.expect;
 @suite
 class TestGenerateWorkspaceId {
     @test public async testGenerateWorkspaceId() {
-        for (let i = 0; i < 100; i++) {
+        for (let i = 0; i < 10; i++) {
             const id = await generateWorkspaceID();
             expect(new GitpodHostUrl().withWorkspacePrefix(id, "eu").workspaceId).to.equal(id);
         }
@@ -32,13 +32,20 @@ class TestGenerateWorkspaceId {
             ["foo", "bar", "foo-bar-"],
             ["f", "bar", ".{2,16}-bar-"],
             ["gitpod-io", "gitpod", "gitpodio-gitpod-"],
+            ["breatheco-de", "python-flask-api-tutorial", "breathecode-pythonflask-"],
+            ["short", "muchlongerthaneleven", "short-muchlongerthanel-"],
+            ["muchlongerthaneleven", "short", "muchlongerthanel-short-"],
             [
                 'this is rather long and has some "§$"% special chars',
                 "also here pretty long and needs abbreviation",
-                "thisisratherlon-alsohere-",
+                "thisisrathe-alsoherepre-",
             ],
-            ["breatheco-de", "python-flask-api-tutorial", "breathecode-pythonflaska-"],
             ["UPPER", "CaSe", "upper-case-"],
+            [
+                "superlongfirstsegment",
+                "---------",
+                "superlong" /* we don't mantch for the whole first segment, because it has different length depending on the animal that is used to replace the -------*/,
+            ],
         ];
         for (const d of data) {
             const id = await generateWorkspaceID(d[0], d[1]);

package/src/util/generate-workspace-id.ts

@@ -3,15 +3,19 @@
  * Licensed under the GNU Affero General Public License (AGPL).
  * See License-AGPL.txt in the project root for license information.
  */
+
 import randomNumber = require("random-number-csprng");
 
 export async function generateWorkspaceID(firstSegment?: string, secondSegment?: string): Promise<string> {
     const firstSeg = clean(firstSegment) || (await random(colors));
-    const secSeg = clean(secondSegment, Math.min(15, 23 - firstSeg.length)) || (await random(animals));
-    return firstSeg + "-" + secSeg + "-" + (await random(characters, 11));
+    const secSeg = clean(secondSegment) || (await random(animals));
+    function fit(makeFit: string, otherSeg: string) {
+        return makeFit.substring(0, Math.max(segLength, 2 * segLength - otherSeg.length));
+    }
+    return fit(firstSeg, secSeg) + "-" + fit(secSeg, firstSeg) + "-" + (await random(characters, segLength));
 }
 
-function clean(segment: string | undefined, maxChars: number = 15) {
+function clean(segment: string | undefined, maxChars: number = 16) {
     if (!segment) {
         return undefined;
     }
@@ -35,6 +39,8 @@ async function random(array: string[], length: number = 1): Promise<string> {
     return result;
 }
 
+const segLength = 11;
+
 const characters = "abcdefghijklmnopqrstuvwxyz0123456789".split("");
 
 export const colors = [

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,24 +310,31 @@ 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,
         severity,
         time: new Date().toISOString(),
-        environment: process.env.KUBE_STAGE,
         context,
         message,
         error,
         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/util/tracing.ts

@@ -22,17 +22,15 @@ export type TraceContextWithSpan = TraceContext & {
 export namespace TraceContext {
     export function startSpan(operation: string, parentCtx?: TraceContext): opentracing.Span {
         const options: opentracing.SpanOptions = {};
-        if (parentCtx && parentCtx.span && !!parentCtx.span.context().toSpanId()) {
-            options.childOf = parentCtx.span;
+
+        // references should contain span id.
+        // cf. https://github.com/jaegertracing/jaeger-client-node/issues/432
+        if (!!parentCtx?.span) {
+            const ctx = parentCtx?.span?.context();
+            if (ctx && !!ctx.toTraceId() && !!ctx.toSpanId()) {
+                options.references = [opentracing.followsFrom(ctx)];
+            }
         }
-        // TODO(gpl) references lead to a huge amount of errors in prod logs. Avoid those until we have time to figure out how to fix it.
-        // if (referencedSpans) {
-        //     // note: allthough followsForm's type says it takes 'opentracing.Span | opentracing.SpanContext', it only works with SpanContext (typing mismatch)
-        //     // note2: we need to filter out debug spans (spanId === "")
-        //     options.references = referencedSpans.filter(s => s !== undefined)
-        //         .filter(s => !!s!.context().toSpanId())
-        //         .map(s => followsFrom(s!.context()));
-        // }
 
         return opentracing.globalTracer().startSpan(operation, options);
     }

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-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

@@ -56,10 +56,27 @@ export interface WorkspaceInstance {
      * Contains information about the image build, if there was any
      */
     imageBuildInfo?: ImageBuildInfo;
+
+    /**
+     * workspace class, also known as workspace size, determines the type of
+     * 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;
 
@@ -98,9 +115,13 @@ export type WorkspaceInstancePhase =
     | "unknown"
 
     // Preparing means that we haven't actually started the workspace instance just yet, but rather
-    // are still preparing for launch. This means we're building the Docker image for the workspace.
+    // are still preparing for launch.
     | "preparing"
 
+    // Building means that we are building the Docker image for the workspace. A workspace will enter this phase only
+    // if an image build is required for that workspace.
+    | "building"
+
     // Pending means the workspace does not yet consume resources in the cluster, but rather is looking for
     // some space within the cluster. If for example the cluster needs to scale up to accomodate the
     // workspace, the workspace will be in Pending state until that happened.
@@ -204,6 +225,12 @@ export interface WorkspaceInstanceRepoStatus {
     totalUnpushedCommits?: number;
 }
 
+// ConfigurationIdeConfig ide config of WorkspaceInstanceConfiguration
+export interface ConfigurationIdeConfig {
+    useLatest?: boolean;
+    desktopIdeAlias?: string;
+}
+
 // WorkspaceInstanceConfiguration contains all per-instance configuration
 export interface WorkspaceInstanceConfiguration {
     // theiaVersion is the version of Theia this workspace instance uses
@@ -221,6 +248,8 @@ export interface WorkspaceInstanceConfiguration {
 
     // supervisorImage is the ref of the supervisor image this instance uses.
     supervisorImage?: string;
+
+    ideConfig?: ConfigurationIdeConfig;
 }
 
 /**

package/src/wsready.ts

@@ -4,7 +4,7 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-// generated using github.com/32leaves/bel on 2022-02-15 11:53:18.380158212 +0000 UTC m=+0.011913675
+// generated using github.com/32leaves/bel on 2022-05-18 18:19:49.011672619 +0000 UTC m=+0.006607361
 // DO NOT MODIFY
 
 export enum WorkspaceInitSource {