@gitpod/gitpod-protocol 0.1.5-me-version.1 → 0.1.5-me-image.2

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

@@ -4,6 +4,14 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
+const REGEX_WORKSPACE_ID = /[0-9a-z]{2,16}-[0-9a-z]{2,16}-[0-9a-z]{8,11}/;
+const REGEX_WORKSPACE_ID_EXACT = new RegExp(`^${REGEX_WORKSPACE_ID.source}$`);
+// We need to parse the workspace id precisely here to get the case '<some-str>-<port>-<wsid>.ws.' right
+const REGEX_WORKSPACE_ID_FROM_HOSTNAME = new RegExp(`(${REGEX_WORKSPACE_ID.source})\.ws`);
+
+const REGEX_WORKSPACE_ID_LEGACY = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/;
+const REGEX_WORKSPACE_ID_LEGACY_EXACT = new RegExp(`^${REGEX_WORKSPACE_ID_LEGACY.source}$`);
+const REGEX_WORKSPACE_ID_LEGACY_FROM_HOSTNAME = new RegExp(`(${REGEX_WORKSPACE_ID_LEGACY.source})\.ws`);
 
 /**
  * Hostname may be of the form:
@@ -13,17 +21,35 @@
  * @param hostname The hostname the request is headed to
  */
 export const parseWorkspaceIdFromHostname = function(hostname: string) {
-    // We need to parse the workspace id precisely here to get the case '<some-str>-<port>-<wsid>.ws.' right
-    const wsIdExpression = /([0-9a-z]{2,16}-[0-9a-z]{2,16}-[0-9a-z]{8})\.ws/g;
-    const match = wsIdExpression.exec(hostname);
+    const match = REGEX_WORKSPACE_ID_FROM_HOSTNAME.exec(hostname);
     if (match && match.length >= 2) {
         return match[1];
     } else {
-        const legacyUrlFormat = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.ws/g;
-        const legacyMatch = legacyUrlFormat.exec(hostname);
+        const legacyMatch = REGEX_WORKSPACE_ID_LEGACY_FROM_HOSTNAME.exec(hostname);
         if (legacyMatch && legacyMatch.length >= 2) {
             return legacyMatch[1];
         }
         return undefined;
     }
-}
+};
+
+/** Equalls UUIDv4 (and REGEX_WORKSPACE_ID_LEGACY!) */
+const REGEX_INSTANCE_ID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/;
+const REGEX_INSTANCE_ID_EXACT = new RegExp(`^${REGEX_INSTANCE_ID.source}$`);
+
+/**
+ * @param maybeId
+ * @returns
+ */
+export const matchesInstanceIdOrLegacyWorkspaceIdExactly = function(maybeId: string): boolean {
+    return REGEX_INSTANCE_ID_EXACT.test(maybeId)
+        || REGEX_WORKSPACE_ID_LEGACY_EXACT.test(maybeId);
+};
+
+/**
+ * @param maybeWorkspaceId
+ * @returns
+ */
+export const matchesNewWorkspaceIdExactly = function(maybeWorkspaceId: string): boolean {
+    return REGEX_WORKSPACE_ID_EXACT.test(maybeWorkspaceId);
+};

package/src/util/repeat.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 { Disposable } from "..";
+import { log } from "./logging";
+
+/**
+ * This intends to be a drop-in replacement for 'setInterval' implemented with a 'setTimeout' chain
+ * to ensure we're not creating more timeouts than we can process.
+ * @param op
+ * @param everyMilliseconds
+ * @returns
+ */
+export function repeat(op: () => Promise<void> | void, everyMilliseconds: number): Disposable {
+    let timer: NodeJS.Timeout | undefined = undefined;
+    let stopped = false;
+    const repeated = () => {
+        if (stopped) {
+            // in case we missed the clearTimeout i 'await'
+            return;
+        }
+
+        timer = setTimeout(async () => {
+            try {
+                await op();
+            } catch (err) {
+                // catch error here to
+                log.error(err);
+            }
+
+            repeated(); // chain ourselves - after the 'await'
+        }, everyMilliseconds);
+    };
+    repeated();
+
+    return Disposable.create(() => {
+        stopped = true;
+        if (timer) {
+            clearTimeout(timer);
+        }
+    });
+}

package/src/util/tracing.spec.ts

@@ -0,0 +1,83 @@
+/**
+ * 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 * as chai from "chai"
+import { TraceContext } from "./tracing";
+import { MockTracer } from "opentracing";
+
+const expect = chai.expect
+
+@suite class TestTracing {
+
+    @test public async testTracingContext_addNestedTags() {
+        const tracer = new MockTracer();
+        const span = tracer.startSpan('testTracingContext_addNestedTags');
+        TraceContext.addNestedTags({ span }, {
+            rpc: {
+                system: "jsonrpc",
+                jsonrpc: {
+                    version: "1.0",
+                    method: "test",
+                    parameters: ["abc", "def"],
+                },
+            },
+        });
+
+        const mockSpan = tracer.report().spans[0];
+        expect(mockSpan.tags()).to.deep.equal({
+            "rpc.system": "jsonrpc",
+            "rpc.jsonrpc.version": "1.0",
+            "rpc.jsonrpc.method": "test",
+            "rpc.jsonrpc.parameters.0": "abc",
+            "rpc.jsonrpc.parameters.1": "def",
+        });
+    }
+
+    @test public async testTracingContext_addNestedTags_null() {
+        const tracer = new MockTracer();
+        const span = tracer.startSpan('testTracingContext_addNestedTags_null');
+        TraceContext.addNestedTags({ span }, {
+            someShape: {
+                thisIsNull: null,
+                thisIsUndefined: undefined,
+            },
+        });
+
+        const mockSpan = tracer.report().spans[0];
+        expect(mockSpan.tags()).to.deep.equal({
+            "someShape.thisIsNull": null,
+            "someShape.thisIsUndefined": undefined,
+        });
+    }
+
+    @test public async testTracingContext_addJsonRPCParameters() {
+        const tracer = new MockTracer();
+        const span = tracer.startSpan('testTracingContext_addJsonRPCParameters');
+        const ctx = { span };
+        TraceContext.addJsonRPCParameters(ctx, {
+            one: "one",
+            two: {
+                name: "two",
+                some: "shape",
+                containing: "PII",
+            },
+            three: "three",
+        });
+
+        const mockSpan = tracer.report().spans[0];
+        expect(mockSpan.tags()).to.deep.equal({
+            "rpc.jsonrpc.parameters.one": "one",
+            "rpc.jsonrpc.parameters.two.containing": "PII",
+            "rpc.jsonrpc.parameters.two.name": "two",
+            "rpc.jsonrpc.parameters.two.some": "shape",
+            "rpc.jsonrpc.parameters.three": "three",
+            "rpc.system": "jsonrpc",
+        });
+    }
+
+}
+module.exports = new TestTracing()

package/src/util/tracing.ts

@@ -6,40 +6,184 @@
 
 
 import * as opentracing from 'opentracing';
-import { TracingConfig, initTracerFromEnv, Sampler, SamplingDecision } from 'jaeger-client';
+import { TracingConfig, initTracerFromEnv } from 'jaeger-client';
+import { Sampler, SamplingDecision } from './jaeger-client-types';
 import { initGlobalTracer } from 'opentracing';
 import { injectable } from 'inversify';
+import { ResponseError } from 'vscode-jsonrpc';
+import { log, LogContext } from './logging';
 
 export interface TraceContext {
     span?: opentracing.Span
 }
+export type TraceContextWithSpan = TraceContext & {
+    span: opentracing.Span
+}
+
 
 export namespace TraceContext {
-    export function startSpan(operation: string, ctx: TraceContext): opentracing.Span {
-        const options: opentracing.SpanOptions = {
-            childOf: ctx.span
+    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;
         }
+        // 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);
     }
 
-    export function startAsyncSpan(operation: string, ctx: TraceContext): opentracing.Span {
-        const options: opentracing.SpanOptions = {};
-        if (!!ctx.span) {
-            options.references = [opentracing.followsFrom(ctx.span.context())];
+    export function childContext(operation: string, parentCtx: TraceContext): TraceContextWithSpan {
+        const span = startSpan(operation, parentCtx);
+        return { span };
+    }
+
+    export function withSpan(operation: string, callback: (ctx: TraceContext) => void, ctx?: TraceContext): void {
+        // if we don't have a parent span, don't create a trace here as those <trace-without-root-spans> are not useful.
+        if (!ctx || !ctx.span || !ctx.span.context()) {
+            callback({});
+            return;
+        }
+
+        const span = TraceContext.startSpan(operation, ctx);
+        try {
+            callback({span});
+        } catch (e) {
+            TraceContext.setError({span}, e);
+            throw e;
+        } finally {
+            span.finish();
         }
-        return opentracing.globalTracer().startSpan(operation, options);
     }
 
-    export function logError(ctx: TraceContext, err: Error) {
+    export function setError(ctx: TraceContext, err: Error) {
         if (!ctx.span) {
             return;
         }
 
-        ctx.span.log({
-            "error": err.message,
-            "stacktrace": err.stack
-        })
-        ctx.span.setTag("error", true)
+        TraceContext.addNestedTags(ctx, {
+            error: {
+                message: err.message,
+                stacktrace: err.stack,
+            },
+        });
+        ctx.span.setTag("error", true);
+    }
+
+    export function setJsonRPCMetadata(ctx: TraceContext, method?: string) {
+        if (!ctx.span) {
+            return;
+        }
+
+        const tags: { [key: string]: any } = {
+            rpc: {
+                system: "jsonrpc",
+                //  version,
+            },
+        };
+        if (method) {
+            tags.rpc.method = method;
+        }
+        addNestedTags(ctx, tags);
+    }
+
+    export function setJsonRPCError(ctx: TraceContext, method: string, err: ResponseError<any>, withStatusCode: boolean = false) {
+        if (!ctx.span) {
+            return;
+        }
+        // not use setError bc this is (most likely) a working operation
+
+        setJsonRPCMetadata(ctx, method);
+        // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/semantic_conventions/rpc.md#json-rpc
+        addNestedTags(ctx, {
+            rpc: {
+                jsonrpc: {
+                    error_code: err.code,
+                    error_message: err.message,
+                },
+            },
+        });
+
+        // the field "status_code" is used by honeycomb to derive insights like success rate, etc. Defaults to "0".
+        if (withStatusCode) {
+            ctx.span.setTag("status_code", err.code);
+        }
+    }
+
+    export function addJsonRPCParameters(ctx: TraceContext, params: { [key: string]: any }) {
+        if (!ctx.span) {
+            return;
+        }
+
+        setJsonRPCMetadata(ctx);
+        addNestedTags(ctx, {
+            rpc: {
+                jsonrpc: {
+                    parameters: params,
+                },
+            },
+        });
+    }
+
+    /**
+     * Does what one would expect from `span.addTags`: Calls `span.addTag` for all keys in map, recursively for objects.
+     * Example:
+     * ```
+     * TraceContext.addNestedTags(ctx, {
+     *    rpc: {
+     *       system: "jsonrpc",
+     *       jsonrpc: {
+     *          version: "1.0",
+     *          method: "test",
+     *          parameters: ["abc", "def"],
+     *       },
+     *    },
+     * });
+     * ```
+     * gives
+     * rpc.system = "jsonrpc"
+     * rpc.jsonrpc.version = "1.0"
+     * rpc.jsonrpc.method = "test"
+     * rpc.jsonrpc.parameters.0 = "abc"
+     * rpc.jsonrpc.parameters.1 = "def"
+     * @param ctx
+     * @param keyValueMap
+     * @returns
+     */
+    export function addNestedTags(ctx: TraceContext, keyValueMap: { [key: string]: any }, _namespace?: string) {
+        if (!ctx.span) {
+            return;
+        }
+        const namespace = _namespace ? `${_namespace}.` : '';
+
+        try {
+            for (const k of Object.keys(keyValueMap)) {
+                const v = keyValueMap[k];
+                if (v instanceof Object) {
+                    addNestedTags(ctx, v, `${namespace}${k}`);
+                } else {
+                    ctx.span.setTag(`${namespace}${k}`, v);
+                }
+            }
+        } catch (err) {
+            // general resilience against odd shapes/parameters
+            log.error("Tracing.addNestedTags", err, { namespace });
+        }
+    }
+
+    export function setOWI(ctx: TraceContext, owi: LogContext) {
+        if (!ctx.span) {
+            return;
+        }
+        addNestedTags(ctx, {
+            context: owi,
+        });
     }
 }
 
@@ -56,11 +200,16 @@ export class TracingManager {
             reporter: {
                 logSpans: false
             },
-            serviceName
+            serviceName,
         }
         const t = initTracerFromEnv(config, {
-            logger: console
+            logger: console,
+            tags: {
+                'service.build.commit': process.env.GITPOD_BUILD_GIT_COMMIT,
+                'service.build.version': process.env.GITPOD_BUILD_VERSION,
+            }
         });
+
         if (opts) {
             if (opts.perOpSampling) {
                 (t as any)._sampler = new PerOperationSampler((t as any)._sampler, opts.perOpSampling);
@@ -132,3 +281,20 @@ export class PerOperationSampler implements Sampler {
         }
     }
 }
+
+// Augment interfaces with an leading parameter "TraceContext" on every method
+type IsValidArg<T> = T extends object ? keyof T extends never ? false : true : true;
+type AddTraceContext<T> =
+    T extends (a: infer A, b: infer B, c: infer C, d: infer D, e: infer E, f: infer F) => infer R ? (
+        IsValidArg<F> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D, e: E, f: F) => R :
+        IsValidArg<E> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D, e: E) => R :
+        IsValidArg<D> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C, d: D) => R :
+        IsValidArg<C> extends true ? (ctx: TraceContextWithSpan, a: A, b: B, c: C) => R :
+        IsValidArg<B> extends true ? (ctx: TraceContextWithSpan, a: A, b: B) => R :
+        IsValidArg<A> extends true ? (ctx: TraceContextWithSpan, a: A) => R :
+        (ctx: TraceContextWithSpan) => Promise<R>
+    ) : never;
+
+export type InterfaceWithTraceContext<T> = {
+    [P in keyof T]: AddTraceContext<T[P]>
+};

package/src/workspace-cluster.ts

@@ -7,7 +7,6 @@
 import * as fs from 'fs';
 import { filePathTelepresenceAware } from './env';
 import { DeepPartial } from "./util/deep-partial";
-import { Without } from './util/without';
 import { PermissionName } from './permission';
 
 export interface WorkspaceCluster {
@@ -50,13 +49,28 @@ export interface TLSConfig {
 export namespace TLSConfig {
     export const loadFromBase64File = (path: string): string => fs.readFileSync(filePathTelepresenceAware(path)).toString("base64");
 }
-export type WorkspaceClusterWoTLS = Without<WorkspaceCluster, "tls">;
+export type WorkspaceClusterWoTLS = Omit<WorkspaceCluster, "tls">;
 export type WorkspaceManagerConnectionInfo = Pick<WorkspaceCluster, "name" | "url" | "tls">;
 
-export type AdmissionConstraint = AdmissionConstraintFeaturePreview | AdmissionConstraintHasRole;
+export type AdmissionConstraint = AdmissionConstraintFeaturePreview | AdmissionConstraintHasPermission | AdmissionConstraintHasUserLevel | AdmissionConstraintHasMoreResources;
 export type AdmissionConstraintFeaturePreview = { type: "has-feature-preview" };
-export type AdmissionConstraintHasRole = { type: "has-permission", permission: PermissionName };
-
+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 namespace AdmissionConstraint {
+    export function is(o: any): o is AdmissionConstraint {
+        return !!o
+            && 'type' in o;
+    }
+    export function isHasPermissionConstraint(o: any): o is AdmissionConstraintHasPermission {
+        return is(o)
+            && o.type === "has-permission";
+    }
+    export function hasPermission(ac: AdmissionConstraint, permission: PermissionName): boolean {
+        return isHasPermissionConstraint(ac) && ac.permission === permission;
+    }
+}
 
 export const WorkspaceClusterDB = Symbol("WorkspaceClusterDB");
 export interface WorkspaceClusterDB {

package/src/workspace-instance.ts

@@ -23,16 +23,22 @@ export interface WorkspaceInstance {
     // The time an instance has switched phase to 'Running'
     startedTime?: string;
 
+    // The time an instance has switched phase to 'Stopping' */
+    stoppingTime?: string;
+
     // The time an instance has switched phase to 'Stopped' */
     stoppedTime?: string;
 
     // ideUrl is the URL at which the workspace is available on the internet
+    // Note: this is nitially empty, filled during starting process!
     ideUrl: string;
 
     // region is the name of the workspace cluster this instance runs in
+    // Note: this is nitially empty, filled during starting process!
     region: string;
 
     // workspaceImage is the name of the Docker image this instance runs
+    // Note: this is nitially empty, filled during starting process!
     workspaceImage: string;
 
     // status is the latest status of the instance that we're aware of
@@ -45,6 +51,11 @@ export interface WorkspaceInstance {
 
     // instance is hard-deleted on the database and about to be collected by db-sync
     readonly deleted?: boolean;
+
+    /**
+     * Contains information about the image build, if there was any
+     */
+     imageBuildInfo?: ImageBuildInfo;
 }
 
 // WorkspaceInstanceStatus describes the current state of a workspace instance
@@ -128,9 +139,6 @@ export interface WorkspaceInstanceConditions {
     // PullingImages marks if the workspace is currently pulling its images. This condition can only be set during PhaseCreating
     pullingImages?: boolean
 
-    // ServiceExists denotes if the workspace theia-/ports- services exist. This condition will be true if either of the two services exist.
-    serviceExists?: boolean
-
     // deployed marks that a workspace instance was sent/deployed at a workspace manager
     deployed?: boolean;
 
@@ -139,6 +147,12 @@ export interface WorkspaceInstanceConditions {
 
     // ISO8601 timestamp when the first user activity was registered in the frontend. Only set if the workspace is running.
     firstUserActivity?: string;
+
+    // headless_task_failed indicates that a headless workspace task failed
+    headlessTaskFailed?: string;
+
+    // stopped_by_request is true if the workspace was stopped using a StopWorkspace call
+    stoppedByRequest?: boolean;
 }
 
 // AdmissionLevel describes who can access a workspace instance and its ports.
@@ -152,9 +166,6 @@ export interface WorkspaceInstancePort {
     // The outward-facing port number
     port: number;
 
-    // An optional inward-facing port number. If not present we'll use port.
-    targetPort?: number;
-
     // The visiblity of this port. Optional for backwards compatibility.
     visibility?: PortVisibility;
 
@@ -200,4 +211,25 @@ export interface WorkspaceInstanceConfiguration {
 
     // ideImage is the ref of the IDE image this instance uses.
     ideImage: string;
+
+    // desktopIdeImage is the ref of the desktop IDE image this instance uses.
+    desktopIdeImage?: string
+
+    // supervisorImage is the ref of the supervisor image this instance uses.
+    supervisorImage?: string;
+}
+
+/**
+ * Holds information about the image build (if there was one) for this WorkspaceInstance
+ */
+export interface ImageBuildInfo {
+    log?: ImageBuildLogInfo,
+}
+
+/**
+ * Holds information about how to access logs for this an image build
+ */
+export interface ImageBuildLogInfo {
+    url: string,
+    headers: { [key: string]: string },
 }

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 2021-06-11 12:57:53.834879928 +0000 UTC m=+0.008335102
+// generated using github.com/32leaves/bel on 2021-11-04 12:16:53.917570766 +0000 UTC m=+0.006002884
 // DO NOT MODIFY
 
 export enum WorkspaceInitSource {

package/lib/messaging/connection-error-handler.d.ts

@@ -1,27 +0,0 @@
-import { Message } from "vscode-jsonrpc";
-export interface ResolvedConnectionErrorHandlerOptions {
-    readonly serverName: string;
-    /**
-     * The maximum amount of errors allowed before stopping the server.
-     */
-    readonly maxErrors: number;
-    /**
-     * The maimum amount of restarts allowed in the restart interval.
-     */
-    readonly maxRestarts: number;
-    /**
-     * In minutes.
-     */
-    readonly restartInterval: number;
-}
-export declare type ConnectionErrorHandlerOptions = Partial<ResolvedConnectionErrorHandlerOptions> & {
-    readonly serverName: string;
-};
-export declare class ConnectionErrorHandler {
-    protected readonly options: ResolvedConnectionErrorHandlerOptions;
-    constructor(options: ConnectionErrorHandlerOptions);
-    shouldStop(error: Error, message?: Message, count?: number): boolean;
-    protected readonly restarts: number[];
-    shouldRestart(): boolean;
-}
-//# sourceMappingURL=connection-error-handler.d.ts.map

package/lib/messaging/connection-error-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection-error-handler.d.ts","sourceRoot":"","sources":["../../src/messaging/connection-error-handler.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAGzC,MAAM,WAAW,qCAAqC;IAClD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CACnC;AAED,oBAAY,6BAA6B,GAAG,OAAO,CAAC,qCAAqC,CAAC,GAAG;IACzF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAC9B,CAAC;AAEF,qBAAa,sBAAsB;IAE/B,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,qCAAqC,CAAC;gBACtD,OAAO,EAAE,6BAA6B;IASlD,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO;IAIpE,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAM;IAC3C,aAAa,IAAI,OAAO;CAc3B"}

package/lib/messaging/connection-error-handler.js

@@ -1,46 +0,0 @@
-"use strict";
-/*
- * Copyright (C) 2017 TypeFox and others.
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
- */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionErrorHandler = void 0;
-var logging_1 = require("../util/logging");
-var ConnectionErrorHandler = /** @class */ (function () {
-    function ConnectionErrorHandler(options) {
-        this.restarts = [];
-        this.options = __assign({ maxErrors: 3, maxRestarts: 5, restartInterval: 3 }, options);
-    }
-    ConnectionErrorHandler.prototype.shouldStop = function (error, message, count) {
-        return !count || count > this.options.maxErrors;
-    };
-    ConnectionErrorHandler.prototype.shouldRestart = function () {
-        this.restarts.push(Date.now());
-        if (this.restarts.length <= this.options.maxRestarts) {
-            return true;
-        }
-        var diff = this.restarts[this.restarts.length - 1] - this.restarts[0];
-        if (diff <= this.options.restartInterval * 60 * 1000) {
-            logging_1.log.error("Server " + this.options.serverName + " crashed " + this.options.maxRestarts + " times in the last " + this.options.restartInterval + " minutes. Will not restart");
-            return false;
-        }
-        this.restarts.shift();
-        return true;
-    };
-    return ConnectionErrorHandler;
-}());
-exports.ConnectionErrorHandler = ConnectionErrorHandler;
-//# sourceMappingURL=connection-error-handler.js.map

package/lib/messaging/connection-error-handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"connection-error-handler.js","sourceRoot":"","sources":["../../src/messaging/connection-error-handler.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;;;;;;;;;;;;AAGH,2CAAsC;AAsBtC;IAGI,gCAAY,OAAsC;QAa/B,aAAQ,GAAa,EAAE,CAAC;QAZvC,IAAI,CAAC,OAAO,cACR,SAAS,EAAE,CAAC,EACZ,WAAW,EAAE,CAAC,EACd,eAAe,EAAE,CAAC,IACf,OAAO,CACb,CAAC;IACN,CAAC;IAED,2CAAU,GAAV,UAAW,KAAY,EAAE,OAAiB,EAAE,KAAc;QACtD,OAAO,CAAC,KAAK,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;IACpD,CAAC;IAGD,8CAAa,GAAb;QACI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;QAC/B,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;YAClD,OAAO,IAAI,CAAC;SACf;QACD,IAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACxE,IAAI,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,GAAG,EAAE,GAAG,IAAI,EAAE;YAClD,aAAG,CAAC,KAAK,CAAC,YAAU,IAAI,CAAC,OAAO,CAAC,UAAU,iBAAY,IAAI,CAAC,OAAO,CAAC,WAAW,2BAAsB,IAAI,CAAC,OAAO,CAAC,eAAe,+BAA4B,CAAC,CAAC;YAC/J,OAAO,KAAK,CAAC;SAChB;QACD,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC;IAChB,CAAC;IAEL,6BAAC;AAAD,CAAC,AA/BD,IA+BC;AA/BY,wDAAsB"}

package/lib/util/context-url.d.ts

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) 2020 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.
- */
-/**
- * The field "contextUrl" might contain prefixes like:
- *  - envvar1=value1/...
- *  - prebuild/...
- * This is the analogon to the (Prefix)ContextParser structure in "server".
- */
-export declare function contextUrlToUrl(contextUrl: string | undefined): URL | undefined;
-//# sourceMappingURL=context-url.d.ts.map

package/lib/util/context-url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-url.d.ts","sourceRoot":"","sources":["../../src/util/context-url.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,GAAG,GAAG,SAAS,CAU/E"}