@torrent-tv/proxy 2.9.73 → 2.9.75

package/test/piece-lru.test.js

@@ -0,0 +1,109 @@
+/**
+ * @file Recency and pinning for resident pieces.
+ *
+ * The pinning cases matter more than the ordering ones: proxy 2.9.71 removed a
+ * torrent's data while a reader was mid-read, and every later read hung. Here
+ * that is meant to be impossible by construction, so it is worth stating in
+ * tests rather than trusting to eviction order.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { PieceLru } from "../services/piece-store/piece-lru.js";
+
+test("evicts the least recently used piece", () => {
+  const lru = new PieceLru(3);
+  lru.touch(1);
+  lru.touch(2);
+  lru.touch(3);
+
+  assert.equal(lru.evictionCandidate(), 1);
+});
+
+test("using a piece again moves it out of the firing line", () => {
+  const lru = new PieceLru(3);
+  lru.touch(1);
+  lru.touch(2);
+  lru.touch(3);
+  lru.touch(1);
+
+  assert.equal(lru.evictionCandidate(), 2);
+});
+
+test("a pinned piece is never offered for eviction", () => {
+  const lru = new PieceLru(3);
+  lru.touch(1);
+  lru.touch(2);
+  lru.touch(3);
+  lru.pin(1);
+
+  assert.equal(lru.evictionCandidate(), 2, "the pinned piece was offered up");
+});
+
+test("pins nest, so one reader leaving does not expose the piece", () => {
+  const lru = new PieceLru(2);
+  lru.touch(1);
+  lru.touch(2);
+
+  // Two sessions reading the same piece — the union-window case.
+  lru.pin(1);
+  lru.pin(1);
+  lru.unpin(1);
+
+  assert.ok(lru.isPinned(1), "the piece stopped being held while a reader still had it");
+  assert.equal(lru.evictionCandidate(), 2);
+
+  lru.unpin(1);
+  assert.equal(lru.isPinned(1), false);
+});
+
+test("reports no candidate rather than evicting a piece in use", () => {
+  const lru = new PieceLru(2);
+  lru.touch(1);
+  lru.touch(2);
+  lru.pin(1);
+  lru.pin(2);
+
+  assert.equal(
+    lru.evictionCandidate(),
+    null,
+    "with every piece held, the caller must wait — not have memory taken from under it"
+  );
+});
+
+test("unpinning something that was never pinned is harmless", () => {
+  const lru = new PieceLru(2);
+  lru.touch(1);
+  lru.unpin(1);
+  lru.unpin(1);
+
+  assert.equal(lru.isPinned(1), false);
+  assert.equal(lru.evictionCandidate(), 1);
+});
+
+test("removal takes a piece out of the ordering", () => {
+  const lru = new PieceLru(3);
+  lru.touch(1);
+  lru.touch(2);
+  lru.remove(1);
+
+  assert.equal(lru.has(1), false);
+  assert.equal(lru.evictionCandidate(), 2);
+  assert.equal(lru.size, 1);
+});
+
+test("fullness follows capacity", () => {
+  const lru = new PieceLru(2);
+  assert.equal(lru.isFull(), false);
+  lru.touch(1);
+  lru.touch(2);
+  assert.equal(lru.isFull(), true);
+  lru.remove(1);
+  assert.equal(lru.isFull(), false);
+});
+
+test("a nonsensical capacity is refused at construction", () => {
+  assert.throws(() => new PieceLru(0), /positive integer/);
+  assert.throws(() => new PieceLru(-1), /positive integer/);
+  assert.throws(() => new PieceLru(1.5), /positive integer/);
+});

package/test/shared-piece-store.test.js

@@ -0,0 +1,302 @@
+/**
+ * @file Pieces in shared memory, spilling to disk.
+ *
+ * The cases worth having are the ones that describe past failures: a buffer
+ * handed out must not be invalidated by later activity (2.9.71 transferred
+ * memory it did not own), and a piece being read must not be evicted (2.9.71
+ * again, at the torrent level).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { SharedPieceStore } from "../services/piece-store/shared-piece-store.js";
+
+const CHUNK = 64 * 1024;
+
+/**
+ * @param {object} [options]
+ * @returns {Promise<{ store: SharedPieceStore, directory: string }>}
+ */
+async function makeStore({ pieces = 4, totalPieces = 16 } = {}) {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "piece-store-"));
+  const store = new SharedPieceStore(CHUNK, {
+    length: CHUNK * totalPieces,
+    memoryBytes: CHUNK * pieces,
+    path: directory,
+    name: "test"
+  });
+  return { store, directory };
+}
+
+/**
+ * @param {number} index
+ * @param {number} [length]
+ * @returns {Buffer}
+ */
+function piece(index, length = CHUNK) {
+  const bytes = Buffer.allocUnsafeSlow(length);
+  bytes.fill(index % 256);
+  bytes.writeUInt32BE(index, 0);
+  return bytes;
+}
+
+/** Promise-shaped wrappers, so the tests read as the sequence they describe. */
+const put = (store, index, bytes) =>
+  new Promise((resolve, reject) => store.put(index, bytes, (error) => (error ? reject(error) : resolve())));
+const get = (store, index, options) =>
+  new Promise((resolve, reject) =>
+    store.get(index, options, (error, bytes) => (error ? reject(error) : resolve(bytes)))
+  );
+
+test("a stored piece comes back byte for byte", async () => {
+  const { store, directory } = await makeStore();
+  try {
+    await put(store, 0, piece(0));
+    const read = await get(store, 0);
+    assert.deepEqual(read, piece(0));
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("pieces past the memory budget spill to disk and read back intact", async () => {
+  const { store, directory } = await makeStore({ pieces: 4, totalPieces: 16 });
+  try {
+    for (let index = 0; index < 10; index += 1) {
+      await put(store, index, piece(index));
+    }
+
+    assert.equal(store.residentCount, 4, "more pieces stayed resident than the budget allows");
+    assert.ok(store.spilledCount >= 6, "pieces over budget were not written out");
+
+    // The earliest pieces can only come from disk now.
+    for (const index of [0, 1, 2, 5]) {
+      assert.deepEqual(await get(store, index), piece(index), `piece ${index} came back wrong`);
+    }
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("the short last piece keeps its own length", async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "piece-store-"));
+  const store = new SharedPieceStore(CHUNK, {
+    length: CHUNK * 3 + 1234,
+    memoryBytes: CHUNK * 4,
+    path: directory,
+    name: "tail"
+  });
+  try {
+    const tail = piece(3, 1234);
+    await put(store, 3, tail);
+    const read = await get(store, 3);
+    assert.equal(read.length, 1234);
+    assert.deepEqual(read, tail);
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("a buffer handed out survives later writes to the same slot", async () => {
+  // This is the shape of the shipped defect: the caller keeps what it was
+  // given while the store carries on working.
+  const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
+  try {
+    await put(store, 0, piece(0));
+    const held = await get(store, 0);
+
+    for (let index = 1; index < 6; index += 1) {
+      await put(store, index, piece(index));
+    }
+
+    assert.deepEqual(held, piece(0), "the buffer changed under its holder");
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("a pinned piece is not evicted to make room", async () => {
+  const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
+  try {
+    await put(store, 0, piece(0));
+    await put(store, 1, piece(1));
+
+    store.pin(0);
+    await put(store, 2, piece(2));
+
+    const located = store.locate(0);
+    assert.ok(located, "the pinned piece was evicted while held");
+    const view = Buffer.from(store.sharedBuffer, located.offset, located.length);
+    assert.deepEqual(view, piece(0), "the pinned piece was overwritten in place");
+
+    store.unpin(0);
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("refuses to make room when every resident piece is being read", async () => {
+  const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
+  try {
+    await put(store, 0, piece(0));
+    await put(store, 1, piece(1));
+    store.pin(0);
+    store.pin(1);
+
+    await assert.rejects(
+      () => put(store, 2, piece(2)),
+      /pinned/,
+      "the store took memory from under a reader instead of refusing"
+    );
+  } finally {
+    store.unpin(0);
+    store.unpin(1);
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("a piece revived from disk is readable by offset again", async () => {
+  const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
+  try {
+    await put(store, 0, piece(0));
+    await put(store, 1, piece(1));
+    await put(store, 2, piece(2)); // pushes piece 0 out to disk
+    assert.equal(store.locate(0), null, "piece 0 should have left memory");
+
+    await get(store, 0); // brings it back
+    const located = store.locate(0);
+    assert.ok(located, "piece 0 was not brought back into memory");
+    const view = Buffer.from(store.sharedBuffer, located.offset, located.length);
+    assert.deepEqual(view, piece(0));
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("a range within a piece is served correctly from memory and from disk", async () => {
+  const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
+  try {
+    const source = piece(4);
+    await put(store, 4, source);
+
+    assert.deepEqual(
+      await get(store, 4, { offset: 100, length: 256 }),
+      source.subarray(100, 356),
+      "range from memory is wrong"
+    );
+
+    await put(store, 5, piece(5));
+    await put(store, 6, piece(6)); // piece 4 spills
+
+    assert.deepEqual(
+      await get(store, 4, { offset: 100, length: 256 }),
+      source.subarray(100, 356),
+      "range after revival is wrong"
+    );
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("takes memory as it needs it, not the whole budget up front", async () => {
+  // The budget is per torrent, so a torrent that is merely open — or one being
+  // probed for its codecs — must not charge the host for the ceiling.
+  const { store, directory } = await makeStore({ pieces: 16, totalPieces: 64 });
+  try {
+    assert.equal(store.capacity, 16);
+    const initial = store.sharedBuffer.byteLength;
+    assert.ok(initial <= CHUNK * 2, `claimed ${initial} bytes before holding anything`);
+
+    for (let index = 0; index < 5; index += 1) {
+      await put(store, index, piece(index));
+    }
+
+    assert.equal(store.residentCount, 5);
+    assert.ok(
+      store.sharedBuffer.byteLength >= CHUNK * 5,
+      "the pool did not grow to hold what was put in it"
+    );
+    assert.ok(
+      store.sharedBuffer.byteLength <= CHUNK * 6,
+      "the pool grew past what was actually needed"
+    );
+
+    // Growing must not move bytes already written.
+    assert.deepEqual(await get(store, 0), piece(0), "an early piece was disturbed by growth");
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("counts where reads were served from, so the budget can be judged", async () => {
+  const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
+  try {
+    await put(store, 0, piece(0));
+    await get(store, 0); // memory
+    await get(store, 0); // memory
+
+    await put(store, 1, piece(1));
+    await put(store, 2, piece(2)); // piece 0 spills
+    await get(store, 0); // disk
+
+    const stats = store.stats();
+    assert.equal(stats.fromMemory, 2, "memory reads miscounted");
+    assert.equal(stats.fromDisk, 1, "disk reads miscounted");
+    // Two: piece 0 goes out to make room for piece 2, then piece 1 goes out to
+    // make room for piece 0 coming back. Reviving costs a spill of its own, and
+    // that is worth seeing in the figures rather than hiding.
+    assert.equal(stats.spills, 2, "spills miscounted");
+    assert.equal(stats.revivals, 1, "revivals miscounted");
+    assert.equal(stats.blockedByPins, 0);
+    assert.equal(stats.capacity, 2);
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("counts a refusal caused by pinned pieces", async () => {
+  const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
+  try {
+    await put(store, 0, piece(0));
+    await put(store, 1, piece(1));
+    store.pin(0);
+    store.pin(1);
+    await assert.rejects(() => put(store, 2, piece(2)));
+
+    assert.equal(store.stats().blockedByPins, 1, "a refusal went unrecorded");
+  } finally {
+    store.unpin(0);
+    store.unpin(1);
+    await new Promise((resolve) => store.destroy(resolve));
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("destroy removes the spill file", async () => {
+  const { store, directory } = await makeStore({ pieces: 2, totalPieces: 8 });
+  await put(store, 0, piece(0));
+  await put(store, 1, piece(1));
+  await put(store, 2, piece(2)); // forces a spill
+
+  const before = await fs.readdir(directory);
+  assert.ok(before.length > 0, "nothing was written to spill");
+
+  await new Promise((resolve) => store.destroy(resolve));
+  const after = await fs.readdir(directory);
+  assert.equal(after.length, 0, "the spill file outlived the store");
+
+  await fs.rm(directory, { recursive: true, force: true });
+});

package/test/webrtc-shim.test.js

@@ -0,0 +1,150 @@
+/**
+ * @file The JavaScript WebRTC stack the torrent thread uses instead of the native one.
+ *
+ * Covers the regression that took the whole proxy down from 2.9.71: a torrent
+ * carrying a `wss://` tracker made the worker create a peer connection, and a
+ * second isolate touching node-datachannel aborts the process outright.
+ *
+ * Also covers the two places werift's data channel differs from the browser's,
+ * because `simple-peer` depends on both: binary payloads must arrive as
+ * `ArrayBuffer` (anything else it pushes through a text decoder, corrupting
+ * torrent data), and the buffered-amount-low event must exist (its backpressure
+ * never resumes without it).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+import {
+  RTCPeerConnection,
+  RTCSessionDescription
+} from "../services/torrent-worker/webrtc-shim.js";
+
+/**
+ * Run a snippet on a worker thread and return what it reports.
+ *
+ * @param {string} source
+ * @returns {Promise<unknown>}
+ */
+function onWorker(source) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(source, { eval: true });
+    const done = (settle) => (value) => {
+      void worker.terminate();
+      settle(value);
+    };
+    worker.once("message", done(resolve));
+    worker.once("error", done(reject));
+  });
+}
+
+test("the worker resolves webrtc-polyfill to the JavaScript stack", async () => {
+  const installUrl = new URL("../services/torrent-worker/install-webrtc-shim.js", import.meta.url).href;
+  const reported = await onWorker(`
+    import { parentPort } from "node:worker_threads";
+    await import(${JSON.stringify(installUrl)});
+    const polyfill = await import("webrtc-polyfill");
+    const pc = new polyfill.RTCPeerConnection({});
+    const channel = pc.createDataChannel("probe");
+    parentPort.postMessage({
+      connection: pc.constructor.name,
+      channel: channel.constructor.name,
+      hasBinaryType: "binaryType" in channel,
+      hasBufferedAmountLow: "onbufferedamountlow" in channel
+    });
+    pc.close();
+  `);
+
+  assert.equal(reported.connection, "ShimPeerConnection");
+  assert.equal(reported.channel, "ShimDataChannel");
+  assert.ok(reported.hasBinaryType, "simple-peer sets binaryType and would get a silent no-op");
+  assert.ok(reported.hasBufferedAmountLow, "simple-peer's backpressure needs this event");
+});
+
+test("a native connection on this thread does not stop the worker's stack", async () => {
+  // The exact pairing that aborted the process before: native here, JavaScript
+  // there, both live at once.
+  const nodeDataChannel = (await import("node-datachannel")).default;
+  const native = new nodeDataChannel.PeerConnection("main-side", { iceServers: [] });
+  native.createDataChannel("keepalive");
+
+  try {
+    const installUrl = new URL("../services/torrent-worker/install-webrtc-shim.js", import.meta.url).href;
+    const reported = await onWorker(`
+      import { parentPort } from "node:worker_threads";
+      await import(${JSON.stringify(installUrl)});
+      const polyfill = await import("webrtc-polyfill");
+      const pc = new polyfill.RTCPeerConnection({});
+      pc.createDataChannel("probe");
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      parentPort.postMessage({ ok: String(pc.localDescription.sdp).startsWith("v=0") });
+      pc.close();
+    `);
+    assert.equal(reported.ok, true);
+  } finally {
+    native.close();
+  }
+});
+
+test("a session description is built from one object, as callers write it", async () => {
+  // simple-peer does `new RTCSessionDescription(data)` with `{ type, sdp }`.
+  // werift's own class takes `(sdp, type)` positionally, so the type would land
+  // in the sdp slot and every peer connection would be rejected with
+  // "invalid sessionDescription" — which is exactly what the field showed.
+  const description = new RTCSessionDescription({ type: "offer", sdp: "v=0\r\n" });
+  assert.equal(description.type, "offer");
+  assert.equal(description.sdp, "v=0\r\n");
+
+  const answerer = new RTCPeerConnection({});
+  const offerer = new RTCPeerConnection({});
+  try {
+    offerer.createDataChannel("probe");
+    const offer = await offerer.createOffer();
+    await offerer.setLocalDescription(offer);
+
+    // The round trip a tracker peer actually performs.
+    await answerer.setRemoteDescription(
+      new RTCSessionDescription({ type: offerer.localDescription.type, sdp: offerer.localDescription.sdp })
+    );
+    assert.equal(answerer.remoteDescription.type, "offer");
+  } finally {
+    answerer.close();
+    offerer.close();
+  }
+});
+
+test("binary payloads reach the reader as ArrayBuffer, byte for byte", async () => {
+  const sender = new RTCPeerConnection({});
+  const receiver = new RTCPeerConnection({});
+  const payload = Buffer.from([0xde, 0xad, 0xbe, 0xef, 0x00, 0xff, 0x7f, 0x80]);
+
+  try {
+    const received = new Promise((resolve, reject) => {
+      receiver.ondatachannel = ({ channel }) => {
+        channel.binaryType = "arraybuffer";
+        channel.onmessage = (event) => resolve(event.data);
+      };
+      setTimeout(() => reject(new Error("nothing arrived within 30s")), 30_000);
+    });
+
+    sender.onicecandidate = ({ candidate }) => candidate && receiver.addIceCandidate(candidate);
+    receiver.onicecandidate = ({ candidate }) => candidate && sender.addIceCandidate(candidate);
+
+    const channel = sender.createDataChannel("payload");
+    await sender.setLocalDescription(await sender.createOffer());
+    await receiver.setRemoteDescription(sender.localDescription);
+    await receiver.setLocalDescription(await receiver.createAnswer());
+    await sender.setRemoteDescription(receiver.localDescription);
+
+    channel.onopen = () => channel.send(payload);
+
+    const data = await received;
+    assert.ok(data instanceof ArrayBuffer, `simple-peer would run this through a text decoder: ${Object.prototype.toString.call(data)}`);
+    assert.deepEqual(Buffer.from(data), payload, "payload was altered in transit");
+  } finally {
+    sender.close();
+    receiver.close();
+  }
+});

package/test/worker-channel.test.js

@@ -0,0 +1,120 @@
+/**
+ * @file The worker transport's memory contract.
+ *
+ * These cover the defect that broke playback in 2.9.71-2.9.73: the worker
+ * handed the main thread ownership of memory it did not own. WebTorrent's piece
+ * cache keeps the buffer it returns and slices it again on the next read, so
+ * transferring it detached the cache's own memory and every later read failed
+ * with "Cannot perform %TypedArray%.prototype.slice on a detached ArrayBuffer".
+ *
+ * The field could not tell us this, because the error never reached anyone: the
+ * worker sent READ_END from its `finally` before the error was posted, and the
+ * main thread had no handler for a read error at all. So a failed read looked
+ * exactly like an empty file.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { MessageChannel } from "node:worker_threads";
+import { createSendStream, createReceiveStream } from "../services/torrent-worker/channel.js";
+
+/**
+ * A buffer standing in for one owned by WebTorrent's piece cache: allocated
+ * outside Node's shared pool, covering its whole region, and still referenced
+ * by its owner after we hand it on.
+ *
+ * @param {number} size
+ * @param {number} fill
+ * @returns {Buffer}
+ */
+function foreignPiece(size, fill) {
+  const piece = Buffer.allocUnsafeSlow(size);
+  piece.fill(fill);
+  return piece;
+}
+
+test("sending a chunk leaves the source buffer usable by its owner", async () => {
+  const { port1, port2 } = new MessageChannel();
+  try {
+    const sender = createSendStream({ port: port1, requestId: 1 });
+    const piece = foreignPiece(1024 * 1024, 7);
+
+    await sender.send(piece);
+
+    // The owner reads its own buffer again, exactly as the piece cache does on
+    // the next request for the same piece.
+    assert.equal(piece.length, 1024 * 1024, "buffer was detached by the send");
+    assert.equal(piece[0], 7);
+    assert.equal(piece.subarray(0, 16).length, 16, "slicing the source failed");
+  } finally {
+    port1.close();
+    port2.close();
+  }
+});
+
+test("a second read of the same piece still returns its bytes", async () => {
+  const { port1, port2 } = new MessageChannel();
+  try {
+    const piece = foreignPiece(512 * 1024, 3);
+
+    for (const requestId of [1, 2]) {
+      const sender = createSendStream({ port: port1, requestId });
+      await sender.send(piece);
+      sender.end();
+    }
+
+    assert.equal(piece[0], 3, "the piece did not survive being sent twice");
+  } finally {
+    port1.close();
+    port2.close();
+  }
+});
+
+test("chunks arrive with their contents intact", async () => {
+  const { port1, port2 } = new MessageChannel();
+  try {
+    const received = [];
+    port2.on("message", (message) => {
+      if (message?.type === "chunk") {
+        received.push(Buffer.from(message.bytes));
+      }
+    });
+
+    const sender = createSendStream({ port: port1, requestId: 1 });
+    const piece = foreignPiece(256 * 1024, 42);
+    await sender.send(piece);
+    sender.end();
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    assert.equal(received.length, 1);
+    assert.equal(received[0].length, 256 * 1024);
+    assert.equal(received[0][0], 42);
+    assert.equal(received[0][received[0].length - 1], 42);
+  } finally {
+    port1.close();
+    port2.close();
+  }
+});
+
+test("a failed read surfaces on the reader instead of ending quietly", async () => {
+  const { port1, port2 } = new MessageChannel();
+  try {
+    const receive = createReceiveStream({
+      port: port1,
+      requestId: 1,
+      onCancel: () => undefined
+    });
+
+    receive.fail(new Error("read failed in the worker"));
+
+    const reader = receive.stream.getReader();
+    await assert.rejects(
+      () => reader.read(),
+      /read failed in the worker/,
+      "the reader saw a clean end instead of the failure"
+    );
+  } finally {
+    port1.close();
+    port2.close();
+  }
+});