@gitpod/gitpod-protocol 0.1.5-wth-test.41 → 0.1.5-yh-vmoptions-fork.3

package/src/messaging/client-call-metrics.ts

@@ -4,94 +4,93 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { injectable } from 'inversify';
-import * as prometheusClient from 'prom-client';
+import { injectable } from "inversify";
+import * as prometheusClient from "prom-client";
 
-type GrpcMethodType = 'unary' | 'client_stream' | 'server_stream' | 'bidi_stream';
+type GrpcMethodType = "unary" | "client_stream" | "server_stream" | "bidi_stream";
 export interface IGrpcCallMetricsLabels {
-	service: string,
-	method: string,
-	type: GrpcMethodType,
+    service: string;
+    method: string;
+    type: GrpcMethodType;
 }
 
 export interface IGrpcCallMetricsLabelsWithCode extends IGrpcCallMetricsLabels {
-	code: string
+    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;
+    started(labels: IGrpcCallMetricsLabels): void;
+    sent(labels: IGrpcCallMetricsLabels): void;
+    received(labels: IGrpcCallMetricsLabels): void;
+    handled(labels: IGrpcCallMetricsLabelsWithCode): void;
 }
 
 @injectable()
 export class PrometheusClientCallMetrics implements IClientCallMetrics {
+    readonly startedCounter: prometheusClient.Counter<string>;
+    readonly sentCounter: prometheusClient.Counter<string>;
+    readonly receivedCounter: prometheusClient.Counter<string>;
+    readonly handledCounter: prometheusClient.Counter<string>;
 
-	readonly startedCounter: prometheusClient.Counter<string>;
-	readonly sentCounter: prometheusClient.Counter<string>;
-	readonly receivedCounter: prometheusClient.Counter<string>;
-	readonly handledCounter: prometheusClient.Counter<string>;
+    constructor() {
+        this.startedCounter = new prometheusClient.Counter({
+            name: "grpc_client_started_total",
+            help: "Total number of RPCs started on the client.",
+            labelNames: ["grpc_service", "grpc_method", "grpc_type"],
+            registers: [prometheusClient.register],
+        });
+        this.sentCounter = new prometheusClient.Counter({
+            name: "grpc_client_msg_sent_total",
+            help: " Total number of gRPC stream messages sent by the client.",
+            labelNames: ["grpc_service", "grpc_method", "grpc_type"],
+            registers: [prometheusClient.register],
+        });
+        this.receivedCounter = new prometheusClient.Counter({
+            name: "grpc_client_msg_received_total",
+            help: "Total number of RPC stream messages received by the client.",
+            labelNames: ["grpc_service", "grpc_method", "grpc_type"],
+            registers: [prometheusClient.register],
+        });
+        this.handledCounter = new prometheusClient.Counter({
+            name: "grpc_client_handled_total",
+            help: "Total number of RPCs completed by the client, regardless of success or failure.",
+            labelNames: ["grpc_service", "grpc_method", "grpc_type", "grpc_code"],
+            registers: [prometheusClient.register],
+        });
+    }
 
-	constructor() {
-		this.startedCounter = new prometheusClient.Counter({
-			name: 'grpc_client_started_total',
-			help: 'Total number of RPCs started on the client.',
-			labelNames: ['grpc_service', 'grpc_method', 'grpc_type'],
-			registers: [prometheusClient.register]
-		});
-		this.sentCounter = new prometheusClient.Counter({
-			name: 'grpc_client_msg_sent_total',
-			help: ' Total number of gRPC stream messages sent by the client.',
-			labelNames: ['grpc_service', 'grpc_method', 'grpc_type'],
-			registers: [prometheusClient.register]
-		});
-		this.receivedCounter = new prometheusClient.Counter({
-			name: 'grpc_client_msg_received_total',
-			help: 'Total number of RPC stream messages received by the client.',
-			labelNames: ['grpc_service', 'grpc_method', 'grpc_type'],
-			registers: [prometheusClient.register]
-		});
-		this.handledCounter = new prometheusClient.Counter({
-			name: 'grpc_client_handled_total',
-			help: 'Total number of RPCs completed by the client, regardless of success or failure.',
-			labelNames: ['grpc_service', 'grpc_method', 'grpc_type', 'grpc_code'],
-			registers: [prometheusClient.register]
-		});
-	}
+    started(labels: IGrpcCallMetricsLabels): void {
+        this.startedCounter.inc({
+            grpc_service: labels.service,
+            grpc_method: labels.method,
+            grpc_type: labels.type,
+        });
+    }
 
-	started(labels: IGrpcCallMetricsLabels): void {
-		this.startedCounter.inc({
-			grpc_service: labels.service,
-			grpc_method: labels.method,
-			grpc_type: labels.type
-		});
-	}
+    sent(labels: IGrpcCallMetricsLabels): void {
+        this.sentCounter.inc({
+            grpc_service: labels.service,
+            grpc_method: labels.method,
+            grpc_type: labels.type,
+        });
+    }
 
-	sent(labels: IGrpcCallMetricsLabels): void {
-		this.sentCounter.inc({
-			grpc_service: labels.service,
-			grpc_method: labels.method,
-			grpc_type: labels.type
-		});
-	}
+    received(labels: IGrpcCallMetricsLabels): void {
+        this.receivedCounter.inc({
+            grpc_service: labels.service,
+            grpc_method: labels.method,
+            grpc_type: labels.type,
+        });
+    }
 
-	received(labels: IGrpcCallMetricsLabels): void {
-		this.receivedCounter.inc({
-			grpc_service: labels.service,
-			grpc_method: labels.method,
-			grpc_type: labels.type
-		});
-	}
-
-	handled(labels: IGrpcCallMetricsLabelsWithCode): void {
-		this.handledCounter.inc({
-			grpc_service: labels.service,
-			grpc_method: labels.method,
-			grpc_type: labels.type,
-			grpc_code: labels.code
-		});
-	}
+    handled(labels: IGrpcCallMetricsLabelsWithCode): void {
+        this.handledCounter.inc({
+            grpc_service: labels.service,
+            grpc_method: labels.method,
+            grpc_type: labels.type,
+            grpc_code: labels.code,
+        });
+    }
 }

package/src/messaging/error.ts

@@ -4,9 +4,10 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-
-
 export namespace ErrorCodes {
+    // 400 Unauthorized
+    export const BAD_REQUEST = 400;
+
     // 401 Unauthorized
     export const NOT_AUTHENTICATED = 401;
 
@@ -61,6 +62,9 @@ export namespace ErrorCodes {
     // 490 Too Many Running Workspace
     export const TOO_MANY_RUNNING_WORKSPACES = 490;
 
+    // 500 Internal Server Error
+    export const INTERNAL_SERVER_ERROR = 500;
+
     // 501 EE Feature
     export const EE_FEATURE = 501;
 
@@ -78,4 +82,7 @@ export namespace ErrorCodes {
 
     // 630 Snapshot Error
     export const SNAPSHOT_ERROR = 630;
-}
+
+    // 640 Headless logs are not available (yet)
+    export const HEADLESS_LOG_NOT_YET_AVAILABLE = 640;
+}

package/src/messaging/handler.ts

@@ -7,7 +7,7 @@
 
 import { MessageConnection } from "vscode-jsonrpc";
 
-export const ConnectionHandler = Symbol('ConnectionHandler');
+export const ConnectionHandler = Symbol("ConnectionHandler");
 
 export interface ConnectionHandler {
     readonly path: string;
@@ -18,10 +18,10 @@ export interface ConnectionEventHandler {
     /**
      * Called when the transport underpinning the connection got closed
      */
-     onTransportDidClose(): void;
+    onTransportDidClose(): void;
 
-     /**
-      * Called when the transport underpinning the connection is (re-)opened
-      */
-     onTransportDidOpen(): void;
+    /**
+     * Called when the transport underpinning the connection is (re-)opened
+     */
+    onTransportDidOpen(): void;
 }

package/src/messaging/node/connection.ts

@@ -6,82 +6,35 @@
  */
 
 import * as ws from "ws";
-import * as http from "http";
-import * as https from "https";
-import * as url from "url";
-import * as net from "net";
-import { MessageConnection } from "vscode-jsonrpc";
-import { createWebSocketConnection, IWebSocket } from "vscode-ws-jsonrpc";
-import { log } from '../../util/logging';
+import { IWebSocket } from "vscode-ws-jsonrpc";
 
-export interface IServerOptions {
-    readonly server: http.Server | https.Server;
-    readonly path?: string;
-    matches?(request: http.IncomingMessage): boolean;
-}
-
-export function createServerWebSocketConnection(options: IServerOptions, onConnect: (connection: MessageConnection) => void): void {
-    openJsonRpcSocket(options, socket => {
-        onConnect(createWebSocketConnection(socket, console));
-    });
-}
-
-export function openJsonRpcSocket(options: IServerOptions, onOpen: (socket: IWebSocket) => void): void {
-    openSocket(options, socket => {
-        const webSocket = toIWebSocket(socket);
-        onOpen(webSocket);
-    });
-}
-
-export interface OnOpen {
-    (webSocket: ws, request: http.IncomingMessage, socket: net.Socket, head: Buffer): void;
-}
-
-export function openSocket(options: IServerOptions, onOpen: OnOpen): void {
-    const wss = new ws.Server({
-        noServer: true,
-            perMessageDeflate: {
-                // don't compress if a message is less than 256kb
-                threshold: 256 * 1024
-            }
-    });
-    options.server.on('upgrade', (request: http.IncomingMessage, socket: net.Socket, head: Buffer) => {
-        const pathname = request.url ? url.parse(request.url).pathname : undefined;
-        if (options.path && pathname === options.path || options.matches && options.matches(request)) {
-            wss.handleUpgrade(request, socket, head, webSocket => {
-                if (webSocket.readyState === webSocket.OPEN) {
-                    onOpen(webSocket, request, socket, head);
-                } else {
-                    webSocket.on('open', () => onOpen(webSocket, request, socket, head));
-                }
-            });
-        }
-    });
-}
-
-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 });
-                }
+        send: (content) => {
+            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/messaging/proxy-factory.ts

@@ -8,8 +8,8 @@
 import { MessageConnection, ResponseError } from "vscode-jsonrpc";
 import { Event, Emitter } from "../util/event";
 import { Disposable } from "../util/disposable";
-import { ConnectionHandler } from './handler';
-import { log } from '../util/logging';
+import { ConnectionHandler } from "./handler";
+import { log } from "../util/logging";
 
 export type JsonRpcServer<Client> = Disposable & {
     /**
@@ -27,10 +27,7 @@ export interface JsonRpcConnectionEventEmitter {
 export type JsonRpcProxy<T> = T & JsonRpcConnectionEventEmitter;
 
 export class JsonRpcConnectionHandler<T extends object> implements ConnectionHandler {
-    constructor(
-        readonly path: string,
-        readonly targetFactory: (proxy: JsonRpcProxy<T>, request?: object) => any
-    ) { }
+    constructor(readonly path: string, readonly targetFactory: (proxy: JsonRpcProxy<T>, request?: object) => any) {}
 
     onConnection(connection: MessageConnection, request?: object): void {
         const factory = new JsonRpcProxyFactory<T>();
@@ -83,7 +80,6 @@ export class JsonRpcConnectionHandler<T extends object> implements ConnectionHan
  * @param <T> - The type of the object to expose to JSON-RPC.
  */
 export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
-
     protected readonly onDidOpenConnectionEmitter = new Emitter<void>();
     protected readonly onDidCloseConnectionEmitter = new Emitter<void>();
 
@@ -101,17 +97,15 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
     }
 
     protected waitForConnection(): void {
-        this.connectionPromise = new Promise(resolve =>
-            this.connectionPromiseResolve = resolve
-        );
-        this.connectionPromise.then(connection => {
+        this.connectionPromise = new Promise((resolve) => (this.connectionPromiseResolve = resolve));
+        this.connectionPromise.then((connection) => {
             connection.onClose(() => this.fireConnectionClosed());
             this.fireConnectionOpened();
         });
     }
 
     fireConnectionClosed() {
-        this.onDidCloseConnectionEmitter.fire(undefined)
+        this.onDidCloseConnectionEmitter.fire(undefined);
     }
 
     fireConnectionOpened() {
@@ -204,35 +198,34 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
      * @returns A callable that executes the JSON-RPC call.
      */
     get(target: T, p: PropertyKey, receiver: any): any {
-        if (p === 'setClient') {
+        if (p === "setClient") {
             return (client: any) => {
                 this.target = client;
             };
         }
-        if (p === 'onDidOpenConnection') {
+        if (p === "onDidOpenConnection") {
             return this.onDidOpenConnectionEmitter.event;
         }
-        if (p === 'onDidCloseConnection') {
+        if (p === "onDidCloseConnection") {
             return this.onDidCloseConnectionEmitter.event;
         }
         const isNotify = this.isNotification(p);
         return (...args: any[]) =>
-            this.connectionPromise.then(connection =>
-                new Promise((resolve, reject) => {
-                    try {
-                        if (isNotify) {
-                            connection.sendNotification(p.toString(), ...args);
-                            resolve(undefined);
-                        } else {
-                            const resultPromise = connection.sendRequest(p.toString(), ...args) as Promise<any>;
-                            resultPromise
-                                .catch((err: any) => reject(err))
-                                .then((result: any) => resolve(result));
+            this.connectionPromise.then(
+                (connection) =>
+                    new Promise((resolve, reject) => {
+                        try {
+                            if (isNotify) {
+                                connection.sendNotification(p.toString(), ...args);
+                                resolve(undefined);
+                            } else {
+                                const resultPromise = connection.sendRequest(p.toString(), ...args) as Promise<any>;
+                                resultPromise.catch((err: any) => reject(err)).then((result: any) => resolve(result));
+                            }
+                        } catch (err) {
+                            reject(err);
                         }
-                    } catch (err) {
-                        reject(err);
-                    }
-                })
+                    }),
             );
     }
 

package/src/oss-allowlist.ts

@@ -0,0 +1,15 @@
+/**
+ * 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.
+ */
+
+export interface OssAllowList {
+    /**
+     * A string that identifies a GitHub/GitLab/Bitbucket identity of the form "<host>/<profilename>"
+     * E.g., "github.com/geropl"
+     */
+    identity: string;
+
+    deleted?: boolean;
+}

package/src/payment-protocol.ts

@@ -4,8 +4,8 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
- export namespace PaymentProtocol {
-    export const UPDATE_GITPOD_SUBSCRIPTION_PATH = '/payment/chargebee'
+export namespace PaymentProtocol {
+    export const UPDATE_GITPOD_SUBSCRIPTION_PATH = "/payment/chargebee";
 }
 
 export interface PlanCoupon {

package/src/permission.ts

@@ -4,34 +4,49 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-
 // see below for explanation
 export const Permissions = {
-    "monitor": undefined,
-    "enforcement": undefined,
+    monitor: undefined,
+    enforcement: undefined,
     "privileged-ws": undefined,
     "registry-access": undefined,
     "admin-users": undefined,
     "admin-workspaces": undefined,
+    "admin-projects": undefined,
     "admin-api": undefined,
     "ide-settings": undefined,
     "new-workspace-cluster": undefined,
 };
-export type PermissionName = keyof (typeof Permissions);
-export const Roles = {"devops": undefined, "viewer": undefined, "admin": undefined };
-export type RoleName = keyof (typeof Roles);
+export type PermissionName = keyof typeof Permissions;
+export const Roles = { devops: undefined, viewer: undefined, admin: undefined };
+export type RoleName = keyof typeof Roles;
 export type RoleOrPermission = RoleName | PermissionName;
 
 export namespace RoleName {
     export const is = (o: any): o is RoleName => {
-        return typeof(o) === 'string'
-            && Role.all().some(r => r.name === o);
-    }
+        return typeof o === "string" && Role.all().some((r) => r.name === o);
+    };
 }
 
 export interface Role {
-    name: RoleName,
-    permissions: PermissionName[],
+    name: RoleName;
+    permissions: PermissionName[];
+}
+
+export namespace RolesOrPermissions {
+    export function toPermissionSet(rolesOrPermissions: RoleOrPermission[] | undefined): Set<PermissionName> {
+        rolesOrPermissions = rolesOrPermissions || [];
+
+        const permissions = new Set<PermissionName>();
+        for (const rop of rolesOrPermissions) {
+            if (Permission.is(rop)) {
+                permissions.add(rop);
+            } else if (RoleName.is(rop)) {
+                Role.getByName(rop).permissions.forEach((p) => permissions.add(p));
+            }
+        }
+        return permissions;
+    }
 }
 
 export namespace Permission {
@@ -50,6 +65,9 @@ export namespace Permission {
     /** The permission for accessing all workspace data */
     export const ADMIN_WORKSPACES: PermissionName = "admin-workspaces";
 
+    /** The permission for accessing all projects data */
+    export const ADMIN_PROJECTS: PermissionName = "admin-projects";
+
     /** The permission to access the admin API */
     export const ADMIN_API: PermissionName = "admin-api";
 
@@ -57,14 +75,11 @@ export namespace Permission {
     export const IDE_SETTINGS: PermissionName = "ide-settings";
 
     export const is = (o: any): o is PermissionName => {
-        return typeof(o) === 'string'
-            && Permission.all().some(p => p === o);
-    }
+        return typeof o === "string" && Permission.all().some((p) => p === o);
+    };
 
     export const all = (): PermissionName[] => {
-        return Object.keys(Permission)
-            .map(k => (Permission as any)[k])
-            .filter(k => typeof(k) === 'string');
+        return Object.keys(Permissions) as PermissionName[];
     };
 }
 
@@ -72,21 +87,13 @@ export namespace Role {
     /** The default role for all Gitpod developers */
     export const DEVOPS: Role = {
         name: "devops",
-        permissions: [
-            Permission.MONITOR,
-            Permission.ENFORCEMENT,
-            Permission.REGISTRY_ACCESS,
-            Permission.IDE_SETTINGS
-        ]
+        permissions: [Permission.MONITOR, Permission.ENFORCEMENT, Permission.REGISTRY_ACCESS, Permission.IDE_SETTINGS],
     };
 
     /** A role for people that are allowed to view Gitpod internals */
     export const VIEWER: Role = {
         name: "viewer",
-        permissions: [
-            Permission.MONITOR,
-            Permission.REGISTRY_ACCESS,
-        ]
+        permissions: [Permission.MONITOR, Permission.REGISTRY_ACCESS],
     };
 
     export const ADMIN: Role = {
@@ -94,13 +101,14 @@ export namespace Role {
         permissions: [
             Permission.ADMIN_USERS,
             Permission.ADMIN_WORKSPACES,
+            Permission.ADMIN_PROJECTS,
             Permission.ADMIN_API,
             Permission.ENFORCEMENT,
-        ]
-    }
+        ],
+    };
 
     export const getByName = (name: RoleName): Role => {
-        const result = Role.all().find(r => r.name === name)
+        const result = Role.all().find((r) => r.name === name);
         if (!result) {
             throw Error("Unknown RoleName: " + name);
         }
@@ -109,7 +117,7 @@ export namespace Role {
 
     export const all = (): Role[] => {
         return Object.keys(Role)
-            .map(k => (Role as any)[k])
-            .filter(k => typeof(k) === 'object');
+            .map((k) => (Role as any)[k])
+            .filter((k) => typeof k === "object");
     };
 }