Implement TCP checks

.github/workflows/health-check.yml

@@ -53,6 +53,8 @@ jobs:
           SOURCES: |
             GitHub->https://github.com
             Facebook->https://facebook.com
+            Never SSL->http://oldsplendidfresheclipse.neverssl.com/online/
+            TCPTest->tcp://tcpbin.com:4242
           GITHUB_TOKEN: ${{ github.token }}
           JOB_NAME: ${{ github.workflow }}
           ARTIFACT_NAME: ${{ env.ARTIFACT_NAME }}

log/src/status.ts → log/src/checks/http.ts

@@ -1,7 +1,7 @@
-import { ActionLogger } from "./github/types";
+import { ActionLogger } from "../github/types";
 import axios, { AxiosError } from "axios";
 
-export class StatusChecker {
+export class HTTPChecker {
     constructor(private readonly siteName: string, private readonly healthEndpoint: string,
         private readonly logger: ActionLogger) {
         logger.info(`Created Status Checker for ${siteName}`);

log/src/checks/tcp.ts

@@ -0,0 +1,95 @@
+import * as net from 'net';
+import { ActionLogger } from "../github/types";
+
+function attemptConnection(host: string, port: number, logger: ActionLogger, retryCount: number = 5): Promise<boolean> {
+  return new Promise((resolve) => {
+    let attempts = 0;
+
+    function attemptConnection() {
+      const socket = new net.Socket();
+
+      // Set a timeout for the connection attempt
+      socket.setTimeout(1000);
+
+      // Attempt to connect to the specified host and port
+      socket.on('connect', () => {
+        // If connected, destroy the socket and resolve true
+        socket.removeAllListeners();  // Clean up listeners
+        socket.destroy();
+        resolve(true);
+
+      });
+
+      // Handle errors that occur during the connection attempt
+      socket.on('error', (err) => {
+        logger.error(`Connection error: ${err.message}`);
+        socket.removeAllListeners();
+        socket.destroy();
+        // If it's anything other then a connection refused, retry
+        if (!err.message.includes("ECONNREFUSED")) {
+            handleRetry();
+        } else {
+            resolve(false); // Resolve the promise on ECONNREFUSED
+        }
+      });
+
+      // Handle timeout scenario
+      socket.on('timeout', () => {
+        logger.error('Connection timeout');
+        socket.destroy();
+        resolve(false);
+      });
+
+      function handleRetry() {
+        if (attempts < retryCount) {
+          attempts += 1;
+          logger.info(`Retrying... (${attempts}/${retryCount})`);
+          setTimeout(attemptConnection, 500); // Retry after .5 seconds
+        } else {
+          resolve(false); // Failed after retrying
+        }
+      }
+
+      socket.connect(port, host);
+    }
+
+    attemptConnection();
+
+  });
+}
+
+export class TCPChecker {
+    constructor(private readonly siteName: string, private readonly healthEndpoint: string,
+        private readonly logger: ActionLogger) {
+        this.logger.info(`Created Status Checker for ${siteName}`);
+    }
+
+    async verifyEndpoint(): Promise<boolean> {
+        const [host, portString] = this.healthEndpoint.replace('tcp://', '').split(':');
+        if (!host) {
+            this.logger.error('Invalid host: Host cannot be empty');
+            return false;
+        }
+
+        // Convert the port part to a number
+        const port = parseInt(portString, 10);
+        if (Number.isNaN(port) || port < 1 || port > 65535) {
+            this.logger.error(`Invalid port number: ${portString}`);
+            return false;
+        }
+
+        try {
+            const isConnected = await attemptConnection(host, port, this.logger);
+        if (isConnected) {
+            this.logger.info('Connection successful');
+            return true;
+        } else {
+            this.logger.info('Connection failed');
+            return false;
+        }
+      } catch (error) {
+            this.logger.error('Error during connection attempt: ' + error);
+            return false;
+      }
+    }
+}

log/src/index.ts

@@ -1,12 +1,13 @@
-import { setFailed, setOutput } from "@actions/core";
+import { setFailed, setOutput, warning } from "@actions/core";
 import { context, getOctokit } from "@actions/github";
 import { Context } from "@actions/github/lib/context";
 
 import { envsafe, num, str } from "envsafe";
 import moment from "moment";
 import { ArtifactManager } from "./github/artifact";
 import { Repo } from "./github/types";
-import { StatusChecker } from "./status";
+import { HTTPChecker } from "./checks/http";
+import { TCPChecker } from "./checks/tcp";
 import { ReportFile } from "./types";
 import { generateCoreLogger } from "./util";
 import { IncidentManager } from "./github/incidents";
@@ -38,6 +39,25 @@ const repo = getRepo(context);
 
 setOutput("repo", `${repo.owner}/${repo.repo}`);
 
+const SUPPORTED_PROTOCOLS = {
+    HTTP: 'http://',
+    HTTPS: 'https://',
+    TCP: 'tcp://'
+} as const;
+
+function isValidUrl(url: string): boolean {
+    try {
+        if (url.startsWith(SUPPORTED_PROTOCOLS.TCP)) {
+            const [host, port] = url.replace(SUPPORTED_PROTOCOLS.TCP, '').split(':');
+            return Boolean(host && port && !Number.isNaN(parseInt(port, 10)));
+        }
+        new URL(url);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
 /**
  * Inputs must be in style of
  * ```log
@@ -73,8 +93,20 @@ const run = async () => {
 
   // Run tests on each required source
   for (const [name, url] of sources) {
-    const statusChecker = new StatusChecker(name, url, logger);
-    const result = await statusChecker.verifyEndpoint();
+    let result: boolean;
+    if (!isValidUrl(url)) {
+        result = false;
+        warning(`Invalid URL format for check: ${name}`);
+    } else if (url.startsWith(SUPPORTED_PROTOCOLS.HTTP) || url.startsWith(SUPPORTED_PROTOCOLS.HTTPS)) {
+        const statusChecker = new HTTPChecker(name, url, logger);
+        result = await statusChecker.verifyEndpoint();
+    } else if (url.startsWith(SUPPORTED_PROTOCOLS.TCP)) {
+        const statusChecker = new TCPChecker(name, url, logger);
+        result = await statusChecker.verifyEndpoint();
+    } else {
+        result = false;
+        warning(`Unsupported protocol for check: ${name} (URL: ${url})`);
+    }
 
     let report: ReportFile["site"][number]["status"] | undefined = siteResult.get(name);
 

log/src/test/index.test.ts

@@ -1,6 +1,6 @@
 import { ArtifactManager } from "../github/artifact";
 import { GitHubClient } from "../github/types";
-import { StatusChecker } from "../status";
+import { HTTPChecker } from "../checks/http";
 import { ReportFile } from "../types";
 
 const sites: Array<[string, string]> = [
@@ -11,7 +11,7 @@ const sites: Array<[string, string]> = [
 
 for (const [site, url] of sites) {
   test(`Test obtaining metrics from ${site}`, async () => {
-    const statusChecker = new StatusChecker(site, url, console);
+    const statusChecker = new HTTPChecker(site, url, console);
     await expect(statusChecker.verifyEndpoint()).resolves.toBe(true);
   })
 }
@@ -20,7 +20,7 @@ test("Write to doc", async () => {
   const siteResult: ReportFile["site"] = [];
 
   for (const [site, url] of sites) {
-    const statusChecker = new StatusChecker(site, url, console);
+    const statusChecker = new HTTPChecker(site, url, console);
     siteResult.push({ name: site, status: [{ timestamp: new Date().getTime(), result: (await statusChecker.verifyEndpoint()) }] });
   }
   const am = new ArtifactManager(null as unknown as GitHubClient, console, "test");