@gitpod/gitpod-protocol 0.1.5-sje-server-installation-admin.8 → 0.1.5-sje-server-installation-admin.15

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() || "";
@@ -877,7 +892,7 @@ export namespace PrebuiltWorkspaceContext {
 }
 
 export interface WithEnvvarsContext extends WorkspaceContext {
-    envvars: UserEnvVarValue[];
+    envvars: EnvVarWithValue[];
 }
 
 export namespace WithEnvvarsContext {

package/src/teams-projects-protocol.ts

@@ -117,13 +117,6 @@ export interface Team {
     deleted?: boolean;
 }
 
-export interface InstallationAdmin {
-    id: string;
-    sendTelemetry: boolean;
-    createdAt: Date;
-    updatedAt: Date;
-}
-
 export type TeamMemberRole = "owner" | "member";
 
 export interface TeamMemberInfo {

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

@@ -34,6 +34,7 @@ const expect = chai.expect
             ['gitpod-io','gitpod','gitpodio-gitpod-'],
             ['this is rather long and has some "§$"% special chars','also here pretty long and needs abbreviation','thisisratherlon-alsohere-'],
             ['breatheco-de', 'python-flask-api-tutorial', 'breathecode-pythonflaska-'],
+            ['UPPER', "CaSe", "upper-case-"]
         ]
         for (const d of data) {
             const id = await generateWorkspaceID(d[0], d[1]);

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

@@ -15,6 +15,7 @@ function clean(segment: string | undefined, maxChars: number = 15) {
   if (!segment) {
     return undefined;
   }
+  segment = segment.toLowerCase();
   let result = '';
   for (let i =0; i < segment.length; i++) {
     if (characters.indexOf(segment[i]) !== -1) {

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