@gitpod/gitpod-protocol 0.1.5-to-new-image.2 → 0.1.5-to-monitor-delete.18

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

@@ -4,94 +4,74 @@
  * See License-AGPL.txt in the project root for license information.
  */
 
-import { injectable } from 'inversify';
-import * as prometheusClient from 'prom-client';
-
-type GrpcMethodType = 'unary' | 'client_stream' | 'server_stream' | 'bidi_stream';
-export interface IGrpcCallMetricsLabels {
-	service: string,
-	method: string,
-	type: GrpcMethodType,
-}
-
-export interface IGrpcCallMetricsLabelsWithCode extends IGrpcCallMetricsLabels {
-	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;
-}
+import { injectable } from "inversify";
+import * as prometheusClient from "prom-client";
+import { IClientCallMetrics, IGrpcCallMetricsLabels, IGrpcCallMetricsLabelsWithCode } from "../util/grpc";
 
 @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;
 
@@ -25,21 +26,30 @@ export namespace ErrorCodes {
     // 410 No User
     export const SETUP_REQUIRED = 410;
 
+    // 411 No User
+    export const NEEDS_VERIFICATION = 411;
+
     // 429 Too Many Requests
     export const TOO_MANY_REQUESTS = 429;
 
     // 430 Repository not whitelisted (custom status code)
     export const REPOSITORY_NOT_WHITELISTED = 430;
 
+    // 450 Payment error
+    export const PAYMENT_ERROR = 450;
+
+    // 451 Out of credits
+    export const PAYMENT_SPENDING_LIMIT_REACHED = 451;
+
+    // 455 Invalid cost center (custom status code)
+    export const INVALID_COST_CENTER = 455;
+
     // 460 Context Parse Error (custom status code)
     export const CONTEXT_PARSE_ERROR = 460;
 
-    // 461 Invalid gitpod yml
+    // 461 Invalid gitpod yml (custom status code)
     export const INVALID_GITPOD_YML = 461;
 
-    // 450 Payment error
-    export const PAYMENT_ERROR = 450;
-
     // 470 User Blocked (custom status code)
     export const USER_BLOCKED = 470;
 
@@ -61,6 +71,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;
 
@@ -81,4 +94,7 @@ export namespace ErrorCodes {
 
     // 640 Headless logs are not available (yet)
     export const HEADLESS_LOG_NOT_YET_AVAILABLE = 640;
-}
+
+    // 650 Invalid Value
+    export const INVALID_VALUE = 650;
+}

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

@@ -10,7 +10,7 @@ import { IWebSocket } from "vscode-ws-jsonrpc";
 
 export function toIWebSocket(ws: ws) {
     return <IWebSocket>{
-        send: content => {
+        send: (content) => {
             if (ws.readyState >= ws.CLOSING) {
                 // ws is already CLOSING/CLOSED, send() would just return an error.
                 return;
@@ -18,23 +18,23 @@ export function toIWebSocket(ws: ws) {
 
             // in general send-errors should trigger an 'error' event already, we just make sure it actually happens.
             try {
-                ws.send(content, err => {
+                ws.send(content, (err) => {
                     if (!err) {
                         return;
                     }
-                    ws.emit('error', err);
+                    ws.emit("error", err);
                 });
             } catch (err) {
-                ws.emit('error', err);
+                ws.emit("error", err);
             }
         },
-        onMessage: cb => ws.on('message', cb),
-        onError: cb => ws.on('error', cb),
-        onClose: cb => ws.on('close', cb),
+        onMessage: (cb) => ws.on("message", cb),
+        onError: (cb) => ws.on("error", cb),
+        onClose: (cb) => ws.on("close", cb),
         dispose: () => {
             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

@@ -9,7 +9,7 @@ export interface OssAllowList {
      * A string that identifies a GitHub/GitLab/Bitbucket identity of the form "<host>/<profilename>"
      * E.g., "github.com/geropl"
      */
-    identity: string,
+    identity: string;
 
-    deleted?: boolean,
-}
+    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,11 +4,10 @@
  * 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,
@@ -18,21 +17,20 @@ export const Permissions = {
     "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 {
@@ -44,11 +42,11 @@ export namespace RolesOrPermissions {
             if (Permission.is(rop)) {
                 permissions.add(rop);
             } else if (RoleName.is(rop)) {
-                Role.getByName(rop).permissions.forEach(p => permissions.add(p));
+                Role.getByName(rop).permissions.forEach((p) => permissions.add(p));
             }
         }
         return permissions;
-    };
+    }
 }
 
 export namespace Permission {
@@ -77,9 +75,8 @@ 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(Permissions) as PermissionName[];
@@ -90,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 = {
@@ -115,11 +104,11 @@ export namespace Role {
             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);
         }
@@ -128,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");
     };
 }