fix: switch from websocket library to ws to avoid native dep issues

edvald · edvald · commit c88432006aad · 2018-10-26T20:12:56.000+02:00
diff --git a/node-client/package-lock.json b/node-client/package-lock.json
diff --git a/node-client/package.json b/node-client/package.json
@@ -53,7 +53,7 @@
     "shelljs": "^0.8.2",
     "tslib": "^1.9.3",
     "underscore": "^1.9.1",
-    "websocket": "^1.0.28"
+    "ws": "^6.1.0"
   },
   "devDependencies": {
     "@types/base-64": "^0.1.2",
@@ -65,9 +65,9 @@
     "@types/node": "^10.12.0",
     "@types/request": "^2.47.1",
     "@types/underscore": "^1.8.9",
-    "@types/websocket": "0.0.40",
+    "@types/ws": "^6.0.1",
     "chai": "^4.2.0",
-    "jasmine": "^3.2.0",
+    "jasmine": "^3.3.0",
     "mocha": "^5.2.0",
     "mock-fs": "^4.7.0",
     "nyc": "^13.1.0",
diff --git a/node-client/src/attach_test.ts b/node-client/src/attach_test.ts
@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 import { ReadableStreamBuffer, WritableStreamBuffer } from 'stream-buffers';
 import { anyFunction, anything, capture, instance, mock, verify, when } from 'ts-mockito';
-import ws = require('websocket');
+import WebSocket = require('ws');
 
 import { Attach } from './attach';
 import { KubeConfig } from './config';
@@ -64,7 +64,7 @@ describe('Attach', () => {
             const path = `/api/v1/namespaces/${namespace}/pods/${pod}/attach`;
             const args = `container=${container}&stderr=true&stdin=true&stdout=true&tty=false`;
 
-            const fakeConn: ws.connection = mock(ws.connection);
+            const fakeConn: WebSocket = mock(WebSocket);
             when(fakeWebSocket.connect(`${path}?${args}`, null, anyFunction())).thenResolve(fakeConn);
 
             await attach.attach(
diff --git a/node-client/src/exec.ts b/node-client/src/exec.ts
@@ -1,6 +1,6 @@
 import querystring = require('querystring');
 import stream = require('stream');
-import ws = require('websocket');
+import WebSocket = require('ws');
 
 import { KubeConfig } from './config';
 import { WebSocketHandler, WebSocketInterface } from './web-socket-handler';
@@ -19,7 +19,7 @@ export class Exec {
     // TODO: make command an array and support multiple args
     public async exec(namespace: string, podName: string, containerName: string, command: string,
                       stdout: stream.Writable | any, stderr: stream.Writable | any, stdin: stream.Readable | any,
-                      tty: boolean): Promise<ws.connection> {
+                      tty: boolean): Promise<WebSocket> {
         const query = {
             stdout: stdout != null,
             stderr: stderr != null,
diff --git a/node-client/src/exec_test.ts b/node-client/src/exec_test.ts
@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 import { ReadableStreamBuffer, WritableStreamBuffer } from 'stream-buffers';
 import { anyFunction, capture, instance, mock, verify, when } from 'ts-mockito';
-import ws = require('websocket');
+import WebSocket = require('ws');
 
 import { KubeConfig } from './config';
 import { Exec } from './exec';
@@ -65,7 +65,7 @@ describe('Exec', () => {
             const path = `/api/v1/namespaces/${namespace}/pods/${pod}/exec`;
             const args = `stdout=true&stderr=true&stdin=true&tty=false&command=${cmd}&container=${container}`;
 
-            const fakeConn: ws.connection = mock(ws.connection);
+            const fakeConn: WebSocket = mock(WebSocket);
             when(fakeWebSocket.connect(`${path}?${args}`, null, anyFunction())).thenResolve(fakeConn);
 
             await exec.exec(
diff --git a/node-client/src/portforward.ts b/node-client/src/portforward.ts
@@ -1,6 +1,6 @@
 import querystring = require('querystring');
 import stream = require('stream');
-import ws = require('websocket');
+import WebSocket = require('ws');
 
 import { KubeConfig } from './config';
 import { WebSocketHandler, WebSocketInterface } from './web-socket-handler';
@@ -20,9 +20,12 @@ export class PortForward {
     }
 
     // TODO: support multiple ports for real...
-    public async portForward(namespace: string, podName: string, targetPorts: number[],
-                             output: stream.Writable, err: stream.Writable,
-                             input: stream.Readable): Promise<ws.connection> {
+    public async portForward(
+        namespace: string, podName: string, targetPorts: number[],
+        output: stream.Writable, err: stream.Writable,
+        input: stream.Readable,
+    ): Promise<WebSocket> {
+
         if (targetPorts.length === 0) {
             throw new Error('You must provide at least one port to forward to.');
         }
diff --git a/node-client/src/web-socket-handler.ts b/node-client/src/web-socket-handler.ts
@@ -1,6 +1,5 @@
-import https = require('https');
 import stream = require('stream');
-import ws = require('websocket');
+import WebSocket = require('ws');
 
 import { V1Status } from './api';
 import { KubeConfig } from './config';
@@ -13,9 +12,11 @@ const protocols = [
 ];
 
 export interface WebSocketInterface {
-    connect(path: string,
-            textHandler: ((text: string) => boolean) | null,
-            binaryHandler: ((stream: number, buff: Buffer) => boolean) | null): Promise<ws.connection>;
+    connect(
+        path: string,
+        textHandler: ((text: string) => boolean) | null,
+        binaryHandler: ((stream: number, buff: Buffer) => boolean) | null,
+    ): Promise<WebSocket>;
 }
 
 export class WebSocketHandler implements WebSocketInterface {
@@ -24,8 +25,10 @@ export class WebSocketHandler implements WebSocketInterface {
     public static readonly StderrStream = 2;
     public static readonly StatusStream = 3;
 
-    public static handleStandardStreams(streamNum: number, buff: Buffer,
-                                        stdout: stream.Writable, stderr: stream.Writable): V1Status | null {
+    public static handleStandardStreams(
+        streamNum: number, buff: Buffer,
+        stdout: stream.Writable, stderr: stream.Writable,
+    ): V1Status | null {
         if (buff.length < 1) {
             return null;
         }
@@ -48,8 +51,11 @@ export class WebSocketHandler implements WebSocketInterface {
         return null;
     }
 
-    public static handleStandardInput(conn: ws.connection,
-                                      stdin: stream.Readable | any, streamNum: number = 0): boolean {
+    public static handleStandardInput(
+        ws: WebSocket,
+        stdin: stream.Readable | any,
+        streamNum: number = 0,
+    ): boolean {
         stdin.on('data', (data) => {
             const buff = Buffer.alloc(data.length + 1);
             buff.writeInt8(streamNum, 0);
@@ -58,11 +64,11 @@ export class WebSocketHandler implements WebSocketInterface {
             } else {
                 buff.write(data, 1);
             }
-            conn.send(buff);
+            ws.send(buff);
         });
 
         stdin.on('end', () => {
-            conn.close();
+            ws.close();
         });
         // Keep the stream open
         return true;
@@ -82,9 +88,11 @@ export class WebSocketHandler implements WebSocketInterface {
      * @param binaryHandler Callback for binary data over the web socket.
      *      Returns true if the connection should be kept alive, false to disconnect.
      */
-    public connect(path: string,
-                   textHandler: ((text: string) => boolean) | null,
-                   binaryHandler: ((stream: number, buff: Buffer) => boolean) | null): Promise<ws.connection> {
+    public connect(
+        path: string,
+        textHandler: ((text: string) => boolean) | null,
+        binaryHandler: ((stream: number, buff: Buffer) => boolean) | null,
+    ): Promise<WebSocket> {
 
         const cluster = this.config.getCurrentCluster();
         if (!cluster) {
@@ -96,37 +104,38 @@ export class WebSocketHandler implements WebSocketInterface {
         const proto = ssl ? 'wss' : 'ws';
         const uri = `${proto}://${target}${path}`;
 
-        const opts: https.RequestOptions = {};
+        const opts: WebSocket.ClientOptions = {};
         // TODO: This doesn't set insecureSSL if skipTLSVerify is set...
         this.config.applytoHTTPSOptions(opts);
 
-        const client = new ws.client({ tlsOptions: opts });
-
         return new Promise((resolve, reject) => {
-            client.on('connect', (connection) => {
-                connection.on('message', (message: ws.IMessage) => {
-                    if (message.type === 'utf8' && message.utf8Data) {
-                        if (textHandler) {
-                            if (!textHandler(message.utf8Data)) {
-                                connection.close();
-                            }
-                        }
-                    } else if (message.type === 'binary' && message.binaryData) {
-                        if (binaryHandler) {
-                            const streamNum = message.binaryData.readInt8(0);
-                            if (!binaryHandler(streamNum, message.binaryData.slice(1))) {
-                                connection.close();
-                            }
-                        }
+            const client = new WebSocket(uri, opts);
+            let resolved = false;
+
+            client.onopen = () => {
+                resolved = true;
+                resolve(client);
+            };
+
+            client.onerror = (err) => {
+                if (!resolved) {
+                    reject(err);
+                }
+            };
+
+            client.onmessage = ({ data }: { data: WebSocket.Data }) => {
+                // TODO: support ArrayBuffer and Buffer[] data types?
+                if (typeof data === 'string') {
+                    if (textHandler && !textHandler(data)) {
+                        client.close();
+                    }
+                } else if (data instanceof Buffer) {
+                    const streamNum = data.readInt8(0);
+                    if (binaryHandler && !binaryHandler(streamNum, data.slice(1))) {
+                        client.close();
                     }
-                });
-                resolve(connection);
-            });
-
-            client.on('connectFailed', (err) => {
-                reject(err);
-            });
-            client.connect(uri, protocols);
+                }
+            };
         });
     }
 }
