Implement new structure

test/socket.test.ts

@@ -0,0 +1,124 @@
+import { field, logger } from "@coder/logger"
+import * as assert from "assert"
+import * as fs from "fs-extra"
+import "leaked-handles"
+import * as net from "net"
+import * as path from "path"
+import * as tls from "tls"
+import { Emitter } from "../src/common/emitter"
+import { generateCertificate, tmpdir } from "../src/node/util"
+import { SocketProxyProvider } from "../src/node/socket"
+
+describe("SocketProxyProvider", () => {
+  const provider = new SocketProxyProvider()
+
+  const onServerError = new Emitter<{ event: string; error: Error }>()
+  const onClientError = new Emitter<{ event: string; error: Error }>()
+  const onProxyError = new Emitter<{ event: string; error: Error }>()
+  const fromServerToClient = new Emitter<string>()
+  const fromClientToServer = new Emitter<string>()
+  const fromClientToProxy = new Emitter<Buffer>()
+
+  let errors = 0
+  let close = false
+  const onError = ({ event, error }: { event: string; error: Error }): void => {
+    if (!close || event === "error") {
+      logger.error(event, field("error", error.message))
+      ++errors
+    }
+  }
+  onServerError.event(onError)
+  onClientError.event(onError)
+  onProxyError.event(onError)
+
+  let server: tls.TLSSocket
+  let proxy: net.Socket
+  let client: tls.TLSSocket
+
+  const getData = <T>(emitter: Emitter<T>): Promise<T> => {
+    return new Promise((resolve) => {
+      const d = emitter.event((t) => {
+        d.dispose()
+        resolve(t)
+      })
+    })
+  }
+
+  before(async () => {
+    const cert = await generateCertificate()
+    const options = {
+      cert: fs.readFileSync(cert.cert),
+      key: fs.readFileSync(cert.certKey),
+      rejectUnauthorized: false,
+    }
+
+    await fs.mkdirp(path.join(tmpdir, "tests"))
+    const socketPath = await provider.findFreeSocketPath(path.join(tmpdir, "tests/tls-socket-proxy"))
+    await fs.remove(socketPath)
+
+    return new Promise((_resolve) => {
+      const resolved: { [key: string]: boolean } = { client: false, server: false }
+      const resolve = (type: "client" | "server"): void => {
+        resolved[type] = true
+        if (resolved.client && resolved.server) {
+          // We don't need any more connections.
+          main.close() // eslint-disable-line @typescript-eslint/no-use-before-define
+          _resolve()
+        }
+      }
+      const main = tls
+        .createServer(options, (s) => {
+          server = s
+          server
+            .on("data", (d) => fromClientToServer.emit(d))
+            .on("error", (error) => onServerError.emit({ event: "error", error }))
+            .on("end", () => onServerError.emit({ event: "end", error: new Error("unexpected end") }))
+            .on("close", () => onServerError.emit({ event: "close", error: new Error("unexpected close") }))
+          resolve("server")
+        })
+        .on("error", (error) => onServerError.emit({ event: "error", error }))
+        .on("end", () => onServerError.emit({ event: "end", error: new Error("unexpected end") }))
+        .on("close", () => onServerError.emit({ event: "close", error: new Error("unexpected close") }))
+        .listen(socketPath, () => {
+          client = tls
+            .connect({ ...options, path: socketPath })
+            .on("data", (d) => fromServerToClient.emit(d))
+            .on("error", (error) => onClientError.emit({ event: "error", error }))
+            .on("end", () => onClientError.emit({ event: "end", error: new Error("unexpected end") }))
+            .on("close", () => onClientError.emit({ event: "close", error: new Error("unexpected close") }))
+            .once("connect", () => resolve("client"))
+        })
+    })
+  })
+
+  it("should work without a proxy", async () => {
+    server.write("server->client")
+    assert.equal(await getData(fromServerToClient), "server->client")
+    client.write("client->server")
+    assert.equal(await getData(fromClientToServer), "client->server")
+    assert.equal(errors, 0)
+  })
+
+  it("should work with a proxy", async () => {
+    assert.equal(server instanceof tls.TLSSocket, true)
+    proxy = (await provider.createProxy(server))
+      .on("data", (d) => fromClientToProxy.emit(d))
+      .on("error", (error) => onProxyError.emit({ event: "error", error }))
+      .on("end", () => onProxyError.emit({ event: "end", error: new Error("unexpected end") }))
+      .on("close", () => onProxyError.emit({ event: "close", error: new Error("unexpected close") }))
+
+    provider.stop() // We don't need more proxies.
+
+    proxy.write("server proxy->client")
+    assert.equal(await getData(fromServerToClient), "server proxy->client")
+    client.write("client->server proxy")
+    assert.equal(await getData(fromClientToProxy), "client->server proxy")
+    assert.equal(errors, 0)
+  })
+
+  it("should close", async () => {
+    close = true
+    client.end()
+    proxy.end()
+  })
+})

test/util.test.ts

@@ -0,0 +1,49 @@
+import * as assert from "assert"
+import { extend, normalize } from "../src/node/util"
+
+describe("util", () => {
+  describe("extend", () => {
+    it("should extend", () => {
+      const a = { foo: { bar: 0, baz: 2 }, garply: 4, waldo: 6 }
+      const b = { foo: { bar: 1, qux: 3 }, garply: "5", fred: 7 }
+      const extended = extend(a, b)
+      assert.deepEqual(extended, {
+        foo: { bar: 1, baz: 2, qux: 3 },
+        garply: "5",
+        waldo: 6,
+        fred: 7,
+      })
+    })
+
+    it("should make deep copies of the original objects", () => {
+      const a = { foo: 0, bar: { frobnozzle: 2 }, mumble: { qux: { thud: 4 } } }
+      const b = { foo: 1, bar: { chad: 3 } }
+      const extended = extend(a, b)
+      assert.notEqual(a.bar, extended.bar)
+      assert.notEqual(b.bar, extended.bar)
+      assert.notEqual(a.mumble, extended.mumble)
+      assert.notEqual(a.mumble.qux, extended.mumble.qux)
+    })
+
+    it("should handle mismatch in type", () => {
+      const a = { foo: { bar: 0, baz: 2, qux: { mumble: 11 } }, garply: 4, waldo: { thud: 10 } }
+      const b = { foo: { bar: [1], baz: { plugh: 8 }, qux: 12 }, garply: { nox: 9 }, waldo: 7 }
+      const extended = extend(a, b)
+      assert.deepEqual(extended, {
+        foo: { bar: [1], baz: { plugh: 8 }, qux: 12 },
+        garply: { nox: 9 },
+        waldo: 7,
+      })
+    })
+  })
+
+  describe("normalize", () => {
+    it("should remove multiple slashes", () => {
+      assert.equal(normalize("//foo//bar//baz///mumble"), "/foo/bar/baz/mumble")
+    })
+
+    it("should remove trailing slashes", () => {
+      assert.equal(normalize("qux///"), "qux")
+    })
+  })
+})