Add Websocket Test v2

README.md

@@ -23,7 +23,7 @@ It is a temporary live demo, all data will be deleted after 10 minutes. Sponsore
 
 ## ⭐ Features
 
-- Monitoring uptime for HTTP(s) / TCP / HTTP(s) Keyword / HTTP(s) Json Query / Ping / DNS Record / Push / Steam Game Server / Docker Containers
+- Monitoring uptime for HTTP(s) / TCP / HTTP(s) Keyword / HTTP(s) Json Query / Websocket / Ping / DNS Record / Push / Steam Game Server / Docker Containers
 - Fancy, Reactive, Fast UI/UX
 - Notifications via Telegram, Discord, Gotify, Slack, Pushover, Email (SMTP), and [90+ notification services, click here for the full list](https://github.com/louislam/uptime-kuma/tree/master/src/components/notifications)
 - 20-second intervals

db/knex_migrations/2025-02-15-2312-add-wstest.js

@@ -0,0 +1,15 @@
+// Add websocket URL
+exports.up = function (knex) {
+    return knex.schema
+        .alterTable("monitor", function (table) {
+            table.text("wsurl");
+            table.boolean("ws_ignore_headers").notNullable().defaultTo(false);
+        });
+};
+
+exports.down = function (knex) {
+    return knex.schema.alterTable("monitor", function (table) {
+        table.dropColumn("wsurl");
+        table.dropColumn("ws_ignore_headers");
+    });
+};

server/model/monitor.js

@@ -96,6 +96,8 @@ class Monitor extends BeanModel {
             parent: this.parent,
             childrenIDs: preloadData.childrenIDs.get(this.id) || [],
             url: this.url,
+            wsurl: this.wsurl,
+            wsIgnoreHeaders: this.getWsIgnoreHeaders(),
             method: this.method,
             hostname: this.hostname,
             port: this.port,
@@ -255,6 +257,14 @@ class Monitor extends BeanModel {
         return Boolean(this.ignoreTls);
     }
 
+    /**
+     * Parse to boolean
+     * @returns {boolean} Should WS headers be ignored?
+     */
+    getWsIgnoreHeaders() {
+        return Boolean(this.wsIgnoreHeaders);
+    }
+
     /**
      * Parse to boolean
      * @returns {boolean} Is the monitor in upside down mode?

server/monitor-types/websocket.js

@@ -1,5 +1,6 @@
 const { MonitorType } = require("./monitor-type");
-const { UP } = require("../../src/util");
+const WebSocket = require("ws");
+const { UP, DOWN } = require("../../src/util");
 const childProcessAsync = require("promisify-child-process");
 
 class websocket extends MonitorType {
@@ -9,8 +10,8 @@ class websocket extends MonitorType {
      * @inheritdoc
      */
     async check(monitor, heartbeat, _server) {
-        //let status_code = await this.attemptUpgrade(monitor.url);
-        let statusCode = await this.curlTest(monitor.url);
+        let statusCode = await this.attemptUpgrade(monitor);
+        //let statusCode = await this.curlTest(monitor.url);
         this.updateStatus(heartbeat, statusCode);
     }
 
@@ -28,40 +29,45 @@ class websocket extends MonitorType {
     }
 
     /**
-     * Checks if status code is 101 and sets status
+     * Checks if status code is 1000(Normal Closure) and sets status and message
      * @param {object} heartbeat The heartbeat object to update.
-     * @param {string} statusCode Status code from curl
+     * @param {[ string, int ]} status Array containing a status message and response code
      * @returns {void}
      */
-    updateStatus(heartbeat, statusCode) {
-        if (statusCode === "101") {
-            heartbeat.status = UP;
-        }
-        heartbeat.msg = statusCode;
+    updateStatus(heartbeat, [ message, code ]) {
+        heartbeat.status = code === 1000 ? UP : DOWN;
+        heartbeat.msg = message;
     }
 
-    // Attempt at using websocket library. Abandoned this idea because of the lack of control of headers. Certain websocket servers don't return the Sec-WebSocket-Accept, which causes websocket to error out.
-    // async attemptUpgrade(hostname) {
-    //     return new Promise((resolve) => {
-    //         const ws = new WebSocket('wss://' + hostname);
+    /**
+     * Uses the builtin Websocket API to establish a connection to target server
+     * @param {object} monitor The monitor object for input parameters.
+     * @returns {[ string, int ]} Array containing a status message and response code
+     */
+    async attemptUpgrade(monitor) {
+        return new Promise((resolve) => {
+            const ws = new WebSocket(monitor.wsurl);
 
-    //         ws.addEventListener("open", (event) => {
-    //             ws.close();
-    //         });
+            ws.addEventListener("open", (event) => {
+                ws.close(1000);
+            });
 
-    //         ws.onerror = (error) => {
-    //             console.log(error.message);
-    //         };
+            ws.onerror = (error) => {
+                // console.log(error.message);
+                // Give user the choice to ignore Sec-WebSocket-Accept header
+                if (monitor.wsIgnoreHeaders && error.message === "Invalid Sec-WebSocket-Accept header") {
+                    resolve([ "101 - OK", 1000 ]);
+                }
+                resolve([ error.message, error.code ]);
+            };
 
-    //         ws.onclose = (event) => {
-    //             if (event.code === 1005) {
-    //                 resolve(true);
-    //             } else {
-    //                 resolve(false);
-    //             }
-    //         };
-    //     })
-    // }
+            ws.onclose = (event) => {
+                // console.log(event.message);
+                // console.log(event.code);
+                resolve([ "101 - OK", event.code ]);
+            };
+        });
+    }
 }
 
 module.exports = {

server/server.js

@@ -790,6 +790,8 @@ let needSetup = false;
                 bean.parent = monitor.parent;
                 bean.type = monitor.type;
                 bean.url = monitor.url;
+                bean.wsurl = monitor.wsurl;
+                bean.wsIgnoreHeaders = monitor.wsIgnoreHeaders;
                 bean.method = monitor.method;
                 bean.body = monitor.body;
                 bean.headers = monitor.headers;

src/lang/en.json

@@ -86,6 +86,7 @@
     "ignoreTLSError": "Ignore TLS/SSL errors for HTTPS websites",
     "ignoreTLSErrorGeneral": "Ignore TLS/SSL error for connection",
     "upsideDownModeDescription": "Flip the status upside down. If the service is reachable, it is DOWN.",
+    "wsIgnoreHeadersDescription": "Test non compliant Websocket servers that don't respond with correct headers.",
     "maxRedirectDescription": "Maximum number of redirects to follow. Set to 0 to disable redirects.",
     "Upside Down Mode": "Upside Down Mode",
     "Max. Redirects": "Max. Redirects",

src/pages/EditMonitor.vue

@@ -117,11 +117,17 @@
                             </div>
 
                             <!-- URL -->
-                            <div v-if="monitor.type === 'websocket' || monitor.type === 'http' || monitor.type === 'keyword' || monitor.type === 'json-query' || monitor.type === 'real-browser' " class="my-3">
+                            <div v-if="monitor.type === 'http' || monitor.type === 'keyword' || monitor.type === 'json-query' || monitor.type === 'real-browser' " class="my-3">
                                 <label for="url" class="form-label">{{ $t("URL") }}</label>
                                 <input id="url" v-model="monitor.url" type="url" class="form-control" pattern="https?://.+" required data-testid="url-input">
                             </div>
 
+                            <!-- Websocket -->
+                            <div v-if="monitor.type === 'websocket'" class="my-3">
+                                <label for="wsurl" class="form-label">{{ $t("URL") }}</label>
+                                <input id="wsurl" v-model="monitor.wsurl" type="wsurl" class="form-control" pattern="wss?://.+" required data-testid="url-input">
+                            </div>
+
                             <!-- gRPC URL -->
                             <div v-if="monitor.type === 'grpc-keyword' " class="my-3">
                                 <label for="grpc-url" class="form-label">{{ $t("URL") }}</label>
@@ -625,6 +631,16 @@
                                 </div>
                             </div>
 
+                            <div v-if="monitor.type === 'websocket' " class="my-3 form-check">
+                                <input id="ws-ignore-headers" v-model="monitor.wsIgnoreHeaders" class="form-check-input" type="checkbox">
+                                <label class="form-check-label" for="ws-ignore-headers">
+                                    {{ $t("Ignore Server Headers") }}
+                                </label>
+                                <div class="form-text">
+                                    {{ $t("wsIgnoreHeadersDescription") }}
+                                </div>
+                            </div>
+
                             <div v-if="monitor.type === 'http' || monitor.type === 'keyword' || monitor.type === 'json-query' || monitor.type === 'redis' " class="my-3 form-check">
                                 <input id="ignore-tls" v-model="monitor.ignoreTls" class="form-check-input" type="checkbox" value="">
                                 <label class="form-check-label" for="ignore-tls">
@@ -1078,6 +1094,8 @@ const monitorDefaults = {
     name: "",
     parent: null,
     url: "https://",
+    wsurl: "wss://",
+    wsIgnoreHeaders: false,
     method: "GET",
     interval: 60,
     retryInterval: 60,
@@ -1731,6 +1749,10 @@ message HealthCheckResponse {
                 this.monitor.url = this.monitor.url.trim();
             }
 
+            if (this.monitor.wsurl) {
+                this.monitor.wsurl = this.monitor.wsurl.trim();
+            }
+
             let createdNewParent = false;
 
             if (this.draftGroupName && this.monitor.parent === -1) {

test/backend-test/test-websocket.js

@@ -0,0 +1,76 @@
+const test = require("node:test");
+const assert = require("node:assert");
+const { websocket } = require("../../server/monitor-types/websocket");
+const { UP, DOWN, PENDING } = require("../../src/util");
+
+test("Test Websocket TLS", async () => {
+    const websocketMonitor = new websocket();
+
+    const monitor = {
+        wsurl: "wss://echo.websocket.org",
+        wsIgnoreHeaders: false,
+    };
+
+    const heartbeat = {
+        msg: "",
+        status: PENDING,
+    };
+
+    await websocketMonitor.check(monitor, heartbeat, {});
+    assert.strictEqual(heartbeat.status, UP);
+    assert.strictEqual(heartbeat.msg, "101 - OK");
+});
+
+test("Test Websocket non TLS", async () => {
+    const websocketMonitor = new websocket();
+
+    const monitor = {
+        wsurl: "ws://ws.ifelse.io",
+        wsIgnoreHeaders: false,
+    };
+
+    const heartbeat = {
+        msg: "",
+        status: PENDING,
+    };
+
+    await websocketMonitor.check(monitor, heartbeat, {});
+    assert.strictEqual(heartbeat.status, UP);
+    assert.strictEqual(heartbeat.msg, "101 - OK");
+});
+
+test("Test a non compliant WS server without ignore", async () => {
+    const websocketMonitor = new websocket();
+
+    const monitor = {
+        wsurl: "wss://c.img-cdn.net/yE4s7KehTFyj/",
+        wsIgnoreHeaders: false,
+    };
+
+    const heartbeat = {
+        msg: "",
+        status: PENDING,
+    };
+
+    await websocketMonitor.check(monitor, heartbeat, {});
+    assert.strictEqual(heartbeat.status, DOWN);
+    assert.strictEqual(heartbeat.msg, "Invalid Sec-WebSocket-Accept header");
+});
+
+test("Test a non compliant WS server with ignore", async () => {
+    const websocketMonitor = new websocket();
+
+    const monitor = {
+        wsurl: "wss://c.img-cdn.net/yE4s7KehTFyj/",
+        wsIgnoreHeaders: true,
+    };
+
+    const heartbeat = {
+        msg: "",
+        status: PENDING,
+    };
+
+    await websocketMonitor.check(monitor, heartbeat, {});
+    assert.strictEqual(heartbeat.status, UP);
+    assert.strictEqual(heartbeat.msg, "101 - OK");
+});