feat(plugins): add reconnect plugin

Author: jeromeludmann

client.ts

@@ -19,6 +19,7 @@ import * as Part from "./plugins/part.ts";
 import * as Ping from "./plugins/ping.ts";
 import * as Privmsg from "./plugins/privmsg.ts";
 import * as Quit from "./plugins/quit.ts";
+import * as Reconnect from "./plugins/reconnect.ts";
 import * as Register from "./plugins/register.ts";
 import * as RegisterOnConnect from "./plugins/register_on_connect.ts";
 import * as ThrowOnError from "./plugins/throw_on_error.ts";
@@ -50,6 +51,7 @@ type ClientParams =
   & Ping.PingParams
   & Privmsg.PrivmsgParams
   & Quit.QuitParams
+  & Reconnect.ReconnectParams
   & Register.RegisterParams
   & RegisterOnConnect.RegisterOnConnectParams
   & Time.TimeParams
@@ -79,6 +81,7 @@ const plugins = [
   Ping.ping,
   Privmsg.privmsg,
   Quit.quit,
+  Reconnect.reconnect,
   Register.register,
   RegisterOnConnect.registerOnConnect,
   ThrowOnError.throwOnError,

plugins/reconnect.ts

@@ -0,0 +1,97 @@
+import { FatalError, Plugin, RemoteAddr } from "../core/client.ts";
+import { Raw } from "../core/parsers.ts";
+
+export interface ReconnectParams {
+  options: {
+    /** Enables auto reconnect.
+     *
+     * Takes `boolean` or `{ attempts?: number, delay?: number }`.
+     *
+     * Default to `false`. */
+    reconnect?: boolean | {
+      /** Number of attempts before giving up.
+       *
+       * Default to `10` attempts. */
+      attempts?: number;
+
+      /** Delay between two attempts, in seconds.
+       *
+       * Default to `5` seconds. */
+      delay?: number;
+    };
+  };
+
+  events: {
+    "reconnecting": RemoteAddr;
+  };
+}
+
+const DEFAULT_ATTEMPTS = 10;
+const DEFAULT_DELAY = 5;
+
+export const reconnect: Plugin<ReconnectParams> = (client, options) => {
+  let reconnect = options.reconnect ?? false;
+
+  if (!reconnect) {
+    return;
+  }
+
+  if (typeof reconnect === "boolean") {
+    reconnect = {
+      attempts: DEFAULT_ATTEMPTS,
+      delay: DEFAULT_DELAY,
+    };
+  }
+
+  const attempts = reconnect.attempts ?? DEFAULT_ATTEMPTS;
+  const delay = reconnect.delay ?? DEFAULT_DELAY;
+
+  let currentAttempts = 0;
+
+  client.on("error", reconnectOnConnectError);
+  client.on("raw", reconnectOnServerError);
+  client.on("connecting", incrementAttempt);
+  client.on("raw", resetAttempts);
+
+  function reconnectOnConnectError(error: FatalError) {
+    if (error.type === "connect") {
+      delayReconnect();
+    }
+  }
+
+  function reconnectOnServerError(msg: Raw) {
+    if (msg.command === "ERROR") {
+      delayReconnect();
+    }
+  }
+
+  function incrementAttempt() {
+    currentAttempts++;
+  }
+
+  function resetAttempts(msg: Raw) {
+    if (msg.command === "RPL_WELCOME") {
+      currentAttempts = 0;
+    }
+  }
+
+  let timeout: number | undefined;
+
+  function delayReconnect() {
+    clearTimeout(timeout);
+
+    if (currentAttempts === attempts) {
+      return;
+    }
+
+    const { remoteAddr } = client.state;
+    const { hostname, port } = remoteAddr;
+
+    client.emit("reconnecting", remoteAddr);
+
+    timeout = setTimeout(
+      async () => await client.connect(hostname, port),
+      delay * 1000,
+    );
+  }
+};

plugins/reconnect_test.ts

@@ -0,0 +1,60 @@
+import { assertEquals } from "../deps.ts";
+import { describe } from "../testing/helpers.ts";
+import { mock } from "../testing/mock.ts";
+import { reconnect } from "./reconnect.ts";
+
+describe("plugins/reconnect", (test) => {
+  const plugins = [reconnect];
+  const noop = () => {};
+
+  test("reconnect on connect error", async () => {
+    const { client } = await mock(
+      plugins,
+      { reconnect: { attempts: 2, delay: 0 } },
+      { withConnection: false },
+    );
+
+    let reconnecting = 0;
+    client.on("reconnecting", () => reconnecting++);
+    client.on("error", noop);
+
+    client.connect("bad_remote_host");
+    await client.once("reconnecting");
+
+    assertEquals(reconnecting, 1);
+  });
+
+  test("reconnect on server error", async () => {
+    const { client, server } = await mock(
+      plugins,
+      { reconnect: { attempts: 2, delay: 0 } },
+      { withConnection: false },
+    );
+
+    let reconnecting = 0;
+    client.on("reconnecting", () => reconnecting++);
+    client.on("error", noop);
+
+    await client.connect("");
+    server.send("ERROR :Closing link: (user@host) [Client exited]");
+    await client.once("reconnecting");
+
+    assertEquals(reconnecting, 1);
+  });
+
+  test("not reconnect if disabled", async () => {
+    const { client } = await mock(
+      plugins,
+      { reconnect: false },
+      { withConnection: false },
+    );
+
+    let reconnecting = 0;
+    client.on("reconnecting", () => reconnecting++);
+    client.on("error", noop);
+
+    client.connect("bad_remote_host");
+
+    assertEquals(reconnecting, 0);
+  });
+});