@gitpod/gitpod-protocol 0.1.5-prs-test-dazzle-rewrite.90 → 0.1.5-prs-dazzlev2-test.3

package/src/installation-admin-protocol.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { v4 as uuidv4 } from 'uuid';
+
+const InstallationAdminSettingsPrototype = {
+    sendTelemetry: true
+}
+
+export type InstallationAdminSettings = typeof InstallationAdminSettingsPrototype;
+
+export namespace InstallationAdminSettings {
+    export function fields(): (keyof InstallationAdminSettings)[] {
+        return Object.keys(InstallationAdminSettingsPrototype) as (keyof InstallationAdminSettings)[];
+    }
+}
+
+export interface InstallationAdmin {
+    id: string;
+    settings: InstallationAdminSettings;
+}
+
+export namespace InstallationAdmin {
+    export function createDefault(): InstallationAdmin {
+        return {
+            id: uuidv4(),
+            settings: {
+                ...InstallationAdminSettingsPrototype,
+            }
+        };
+    }
+}

package/src/messaging/node/connection.ts

@@ -6,37 +6,34 @@
  */
 
 import * as ws from "ws";
-import * as http from "http";
-import * as net from "net";
 import { IWebSocket } from "vscode-ws-jsonrpc";
-import { log } from '../../util/logging';
 
-export interface OnOpen {
-    (webSocket: ws, request: http.IncomingMessage, socket: net.Socket, head: Buffer): void;
-}
-
-export function toIWebSocket(webSocket: ws) {
-    let sendsAfterOpen = 0;
+export function toIWebSocket(ws: ws) {
     return <IWebSocket>{
         send: content => {
-            if (webSocket.readyState !== ws.OPEN) {
-                if (sendsAfterOpen++ > 3) {
-                    //log.debug(`Repeated try to send on closed web socket (readyState was ${webSocket.readyState})`, { ws });
-                }
+            if (ws.readyState >= ws.CLOSING) {
+                // ws is already CLOSING/CLOSED, send() would just return an error.
                 return;
             }
-            webSocket.send(content, err => {
-                if (err) {
-                    log.error('error in ws.send()', err, { ws });
-                }
-            })
+
+            // in general send-errors should trigger an 'error' event already, we just make sure it actually happens.
+            try {
+                ws.send(content, err => {
+                    if (!err) {
+                        return;
+                    }
+                    ws.emit('error', err);
+                });
+            } catch (err) {
+                ws.emit('error', err);
+            }
         },
-        onMessage: cb => webSocket.on('message', cb),
-        onError: cb => webSocket.on('error', cb),
-        onClose: cb => webSocket.on('close', cb),
+        onMessage: cb => ws.on('message', cb),
+        onError: cb => ws.on('error', cb),
+        onClose: cb => ws.on('close', cb),
         dispose: () => {
-            if (webSocket.readyState < ws.CLOSING) {
-                webSocket.close();
+            if (ws.readyState < ws.CLOSING) {
+                ws.close();
             }
         }
     };

package/src/protocol.ts

@@ -154,12 +154,23 @@ export interface UserFeatureSettings {
 export const WorkspaceFeatureFlags = { "full_workspace_backup": undefined, "fixed_resources": undefined };
 export type NamedWorkspaceFeatureFlag = keyof (typeof WorkspaceFeatureFlags);
 
-export interface UserEnvVarValue {
-    id?: string;
+export interface EnvVarWithValue {
     name: string;
-    repositoryPattern: string;
     value: string;
 }
+
+export interface ProjectEnvVarWithValue extends EnvVarWithValue {
+    id: string;
+    projectId: string;
+    censored: boolean;
+}
+
+export type ProjectEnvVar = Omit<ProjectEnvVarWithValue, 'value'>;
+
+export interface UserEnvVarValue extends EnvVarWithValue {
+    id?: string;
+    repositoryPattern: string; // DEPRECATED: Use ProjectEnvVar instead of repositoryPattern - https://github.com/gitpod-com/gitpod/issues/5322
+}
 export interface UserEnvVar extends UserEnvVarValue {
     id: string;
     userId: string;
@@ -168,10 +179,12 @@ export interface UserEnvVar extends UserEnvVarValue {
 
 export namespace UserEnvVar {
 
+    // DEPRECATED: Use ProjectEnvVar instead of repositoryPattern - https://github.com/gitpod-com/gitpod/issues/5322
     export function normalizeRepoPattern(pattern: string) {
         return pattern.toLocaleLowerCase();
     }
 
+    // DEPRECATED: Use ProjectEnvVar instead of repositoryPattern - https://github.com/gitpod-com/gitpod/issues/5322
     export function score(value: UserEnvVarValue): number {
         // We use a score to enforce precedence:
         //      value/value = 0
@@ -194,6 +207,7 @@ export namespace UserEnvVar {
         return score;
     }
 
+    // DEPRECATED: Use ProjectEnvVar instead of repositoryPattern - https://github.com/gitpod-com/gitpod/issues/5322
     export function filter<T extends UserEnvVarValue>(vars: T[], owner: string, repo: string): T[] {
         let result = vars.filter(e => {
             const [ownerPattern, repoPattern] = splitRepositoryPattern(e.repositoryPattern);
@@ -241,6 +255,7 @@ export namespace UserEnvVar {
         return result;
     }
 
+    // DEPRECATED: Use ProjectEnvVar instead of repositoryPattern - https://github.com/gitpod-com/gitpod/issues/5322
     export function splitRepositoryPattern(repositoryPattern: string): string[] {
         const patterns = repositoryPattern.split('/');
         const repoPattern = patterns.pop() || "";
@@ -876,8 +891,20 @@ export namespace PrebuiltWorkspaceContext {
     }
 }
 
+export interface WithReferrerContext extends WorkspaceContext {
+    referrer: string
+    referrerIde?: string
+}
+
+export namespace WithReferrerContext {
+    export function is(context: any): context is WithReferrerContext {
+        return context
+            && 'referrer' in context;
+    }
+}
+
 export interface WithEnvvarsContext extends WorkspaceContext {
-    envvars: UserEnvVarValue[];
+    envvars: EnvVarWithValue[];
 }
 
 export namespace WithEnvvarsContext {

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

@@ -150,7 +150,7 @@ export class GitpodHostUrl {
         return undefined;
     }
 
-    get blobServe(): boolean {
+    get blobServe(): boolean {
         const hostSegments = this.url.host.split(".");
         if (hostSegments[0] === 'blobserve') {
             return true;

package/src/util/tracing.ts

@@ -24,12 +24,15 @@ export type TraceContextWithSpan = TraceContext & {
 export namespace TraceContext {
     export function startSpan(operation: string, parentCtx?: TraceContext, ...referencedSpans: (opentracing.Span | undefined)[]): opentracing.Span {
         const options: opentracing.SpanOptions = {};
-        if (parentCtx) {
+        if (parentCtx && parentCtx.span && !!parentCtx.span.context().toSpanId()) {
             options.childOf = parentCtx.span;
         }
         if (referencedSpans) {
             // note: allthough followsForm's type says it takes 'opentracing.Span | opentracing.SpanContext', it only works with SpanContext (typing mismatch)
-            options.references = referencedSpans.filter(s => s !== undefined).map(s => followsFrom(s!.context()));
+            // 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);