update due to wol-client

Author: CodeShellDev

src/wol.js

@@ -1,5 +1,6 @@
 const express = require("express")
 const wss = require("./wss")
+const WebSocket = require("ws")
 
 const { logger } = require("./utils/logger")
 const { ENV } = require("./env")
@@ -101,30 +102,29 @@ function getDataByHostname(hostname) {
 	}
 }
 
-async function trySendWakeupPackets(hosts, wolUrl) {
-	if (!hosts?.length) return null
-	if (typeof wolUrl !== "string" || wolUrl.trim() === "") return null
+async function trySendWakeupPackets(client, hosts, wolUrl) {
+	if (!hosts?.length) return { err: true }
+	if (!client) return { err: true }
+	if (!wolUrl) return { err: true }
 
-	let output = ""
 	let err = false
 
+	const baseURL = new URL(wolUrl)
+	const protocol = baseURL.protocol === "https:" ? "wss" : "ws"
+
 	const virtualPort =
 		ENV.virtualPort && `${ENV.virtualPort}`.trim() !== ""
 			? ENV.virtualPort
 			: null
 
 	for (const host of hosts) {
-		const ip = host.ip
-
 		let targetUrl = wolUrl
 		let payload
 
 		if (host.isVirtual) {
-			if (!virtualPort) {
-				continue
-			}
+			if (!virtualPort) continue
 
-			targetUrl = `http://${ip}:${virtualPort}`
+			targetUrl = `http://${host.ip}:${virtualPort}`
 			payload = {
 				id: host.id,
 				startupTime: host.startupTime,
@@ -142,26 +142,90 @@ async function trySendWakeupPackets(hosts, wolUrl) {
 		)
 
 		const response = await post(targetUrl, payload)
-		if (!response?.message) {
+		if (!response?.client_id) {
 			err = true
+
+			sendToClient(client, {
+				success: false,
+				error: true,
+				message: `WoL request failed`,
+			})
+
+			errorClient(client, err)
+
 			break
 		}
 
-		const msg = response.message
+		const hostClientId = response.client_id
 
-		if (msg.output && !host.isVirtual) {
-			output += msg.output
-		}
+		const wsURL = `${protocol}://${baseURL.host}/ws?client_id=${hostClientId}`
+		const ws = new WebSocket(wsURL)
+
+		let finished = false
+
+		ws.on("message", (msg) => {
+			let data
+			try {
+				data = JSON.parse(msg)
+			} catch {
+				return
+			}
+
+			if (data.error === true) {
+				err = true
+			}
+
+			sendToClient(client, {
+				success: false,
+				error: err,
+				message: data.message,
+			})
+
+			errorClient(client, err)
+
+			if (data.success === true) {
+				finished = true
+				ws.close()
+			} else if (err) {
+				ws.close()
+			}
+		})
+
+		ws.on("close", () => {
+			if (!finished && !err) {
+				err = true
+
+				sendToClient(client, {
+					error: true,
+					message: `WoL WebSocket closed unexpectedly`,
+				})
+
+				errorClient(client, err)
+			}
+		})
 
-		if (msg.success === false) {
+		ws.on("error", () => {
 			err = true
-			break
-		}
+
+			logger.error("Error during WebSocket connection: ", err.message)
+
+			sendToClient(client, {
+				success: false,
+				error: true,
+				message: `WoL WebSocket error for host`,
+			})
+		})
+
+		await new Promise((resolve) => {
+			ws.on("close", resolve)
+			ws.on("error", resolve)
+		})
+
+		if (err) break
 	}
 
-	return { output, err }
+	return { err }
 }
-
 async function waitForHostUp(url, options = {}) {
 	const { interval = 3000, timeout = 60000 } = options
 	const start = Date.now()
@@ -209,9 +273,11 @@ async function startProcessing(req, res) {
 		return res.json({ error: true, message: "No route for hostname" })
 	}
 
-	const requestId = wss.createRequestId()
+	const clientID = wss.createClientID()
 
-	res.json({ error: false, message: "Start request received", requestId })
+	res.json({
+		client_id: clientID,
+	})
 
 	const { hosts, routeAttributes } = resolved
 
@@ -221,23 +287,18 @@ async function startProcessing(req, res) {
 
 	let wolResult = null
 
-	if (wolEnabled && hosts.length > 0) {
-		wolResult = await trySendWakeupPackets(hosts, ENV.wolURL)
-	}
-
-	const ws = wss.getClient(requestId)
+	const ws = wss.getClient(clientID)
 
 	if (!ws) {
 		return
 	}
 
+	if (wolEnabled && hosts.length > 0) {
+		wolResult = await trySendWakeupPackets(ws, hosts, ENV.wolURL)
+	}
+
 	if (wolResult) {
 		err = wolResult.err
-
-		sendToClient(ws, {
-			error: err,
-			message: wolResult.output,
-		})
 	}
 
 	errorClient(ws, err)
@@ -295,7 +356,6 @@ async function startProcessing(req, res) {
 		message: "",
 		error: err,
 		host: serviceURL.hostname,
-		requestId,
 	})
 }
 

src/wss.js

@@ -10,15 +10,15 @@ function attach(server, app, router) {
 
 	wss.on("connection", (socket, req) => {
 		const url = new URL(req.url, "http://localhost")
-		const requestId = url.searchParams.get("requestId")
+		const clientID = url.searchParams.get("client_id")
 
-		if (!requestId) {
-			socket.send(JSON.stringify({ error: true, message: "Missing requestId" }))
+		if (!clientID) {
+			socket.send(JSON.stringify({ error: true, message: "Missing client_id" }))
 			socket.close()
 			return
 		}
 
-		clients[requestId] = socket
+		clients[clientID] = socket
 
 		socket.isAlive = true
 
@@ -37,19 +37,19 @@ function attach(server, app, router) {
 
 		socket.on("close", () => {
 			clearInterval(interval)
-			delete clients[requestId]
+			delete clients[clientID]
 		})
 	})
 
 	app.use("/", router)
 }
 
-function getClient(requestId) {
-	return clients[requestId]
+function getClient(clientID) {
+	return clients[clientID]
 }
 
-function createRequestId() {
+function createClientID() {
 	return uuidv4()
 }
 
-module.exports = { attach, getClient, createRequestId }
+module.exports = { attach, getClient, createClientID }

views/home.ejs

@@ -280,14 +280,14 @@
 					if (!response.ok) throw new Error(`HTTP error ${response.status}`)
 
 					const data = await response.json()
-					const requestId = data.requestId
-					if (!requestId) throw new Error("No requestId returned from server")
+					const clientID = data.client_id
+					if (!clientID) throw new Error("No requestId returned from server")
 
 					logEl.textContent += "Process started. Waiting for service...\n"
 
 					const protocol = location.protocol === "https:" ? "wss" : "ws"
 					const ws = new WebSocket(
-						`${protocol}://${location.host}/ws?requestId=${requestId}`
+						`${protocol}://${location.host}/ws?client_id=${clientID}`
 					)
 
 					ws.onopen = () => {