Merge branch 'dev' into main

Author: CodeShellDev

.github/templates/README.template.md

@@ -1,4 +1,4 @@
-# WoL Client
+<h1 align="center">WoL Client</h1>
 
 <p align="center">
 🖥️ Wake-on-LAN API · WebSocket & HTTP Interface · Docker Ready
@@ -81,7 +81,7 @@ curl -X POST "http://wol-client:5555/start" \
 > [!NOTE]
 > The `startupTime` field may be omitted. In that case, the [`PING_INTERVAL`](#ping_interval) and [`PING_RETRIES`](#ping_retries) settings will be used to periodically ping the host.
 
-**WoL Client** will respond with a `client_id`, which can be used to establish a **WebSocket connection** at `ws://wol-client/ws`.  
+**WoL Client** will respond with a `client_id`, which can be used to establish a **WebSocket connection** at `ws://wol-client:5555/ws`.  
 This WebSocket will send updates for each step of the process. The response contains:
 
 - `success`: `true` if the process finished successfully.

README.md

@@ -1,4 +1,4 @@
-# WoL Client
+<h1 align="center">WoL Client</h1>
 
 <p align="center">
 🖥️ Wake-on-LAN API · WebSocket & HTTP Interface · Docker Ready
@@ -94,7 +94,7 @@ curl -X POST "http://wol-client:5555/start" \
 > [!NOTE]
 > The `startupTime` field may be omitted. In that case, the [`PING_INTERVAL`](#ping_interval) and [`PING_RETRIES`](#ping_retries) settings will be used to periodically ping the host.
 
-**WoL Client** will respond with a `client_id`, which can be used to establish a **WebSocket connection** at `ws://wol-client/ws`.  
+**WoL Client** will respond with a `client_id`, which can be used to establish a **WebSocket connection** at `ws://wol-client:5555/ws`.  
 This WebSocket will send updates for each step of the process. The response contains:
 
 - `success`: `true` if the process finished successfully.

internals/config/config.go

@@ -10,7 +10,6 @@ import (
 
 var ENV = &structure.ENV{
 	LOG_LEVEL: "info",
-	PORT: "5555",
 	PING_INTERVAL: 5,
 	PING_RETRIES: 7,
 }

internals/server/http.go

@@ -3,6 +3,7 @@ package server
 import (
 	"encoding/json"
 	"net/http"
+	"strconv"
 	"time"
 
 	"github.com/codeshelldev/gotl/pkg/logger"
@@ -40,99 +41,133 @@ func httpHandler(w http.ResponseWriter, req *http.Request) {
         "client_id": clientID,
     }
 
+	respBytes, err := json.Marshal(resp)
+
+	if err != nil {
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+	}
+
+	logger.Debug("Sending client_id to client")
+
     w.Header().Set("Content-Type", "application/json")
-    json.NewEncoder(w).Encode(resp)
+	w.Header().Set("Content-Length", strconv.Itoa(len(respBytes)))
+    w.Write(respBytes)
+
+	f, ok := w.(http.Flusher)
+	if ok { 
+		f.Flush() 
+	}
+
+	logger.Debug("Waiting for client to establish websocket connection")
 
-	client, err := waitForClient(clientID, time.Duration(15 * time.Second))
+	client, err := waitForClient(clientID, time.Duration(20 * time.Second))
 
 	if err != nil {
 		logger.Error("Could not get client: ", err.Error())
 		return
 	}
 
+	logger.Debug("Pinging host")
+
 	reachable, err := tryPing(client, body.IP, 
 		func() (bool, error) {
 			sendToClient(client, map[string]any{
 				"success": true,
-				"message": "Host is reachable",
+				"message": "Host is reachable.",
 			})
 			return true, nil
 		},
 		func() (bool, error) {
 			sendToClient(client, map[string]any{
 				"success": false,
-				"message": "Host is unreachable",
+				"message": "Host is unreachable.",
 			})
 			return false, nil
 		},
 	)
 
+	logger.Debug("Host is unreachable")
+
 	if reachable || err != nil {
 		closeClient(client)
 		return
 	}
 
 	sendToClient(client, map[string]any{
 		"success": false,
-		"message": "Sending wakeup packets",
+		"message": "Sending wakeup packets...",
 	})
 
-	addr := body.IP
+	addr := body.IP + ":9"
 
 	if body.Addr != "" {
 		addr = body.Addr
 	}
 
+	logger.Debug("Waking up host")
+
 	err = wol.Wake(addr, body.Mac)
 
 	if err != nil {
+		logger.Error("Error waking up host: ", err.Error())
+
 		sendToClient(client, map[string]any{
 			"success": false,
 			"error": true,
-			"message": "Could not wake up host",
+			"message": "Could not wake up host.",
 		})
 
 		closeClient(client)
 		return
 	}
 
+	logger.Debug("Pinging host again")
+
 	if body.StartupTime != nil {
 		time.Sleep(time.Duration(*body.StartupTime) * time.Second)
 
-		reachable, err = tryPing(client, body.Addr, 
+		reachable, err = tryPing(client, body.IP, 
 			func() (bool, error) {
 				sendToClient(client, map[string]any{
 					"success": true,
-					"message": "Host is now reachable",
+					"message": "Host is now reachable.",
 				})
 				return true, nil
 			},
 			func() (bool, error) {
 				sendToClient(client, map[string]any{
 					"success": false,
 					"error": true,
-					"message": "Host is still unreachable",
+					"message": "Host is still unreachable.",
 				})
 				return false, nil
 			},
 		)
 
+		if reachable {
+			logger.Debug("Host is now reachable.")
+		} else {
+			logger.Debug("Host is still unreachable.")
+		}
+
 		closeClient(client)
 		return
 	}
 
-	success, err := tryPingInterval(client, config.ENV.PING_INTERVAL, config.ENV.PING_RETRIES, body.Addr)
+	success, err := tryPingInterval(client, config.ENV.PING_INTERVAL, config.ENV.PING_RETRIES, body.IP)
 
 	if success {
+		logger.Debug("Host is now reachable.")
 		sendToClient(client, map[string]any{
 			"success": true,
-			"message": "Host is now reachable",
+			"message": "Host is now reachable.",
 		})
 	} else if !success && err == nil {
+		logger.Debug("Host is still unreachable.")
 		sendToClient(client, map[string]any{
 			"success": false,
 			"error": true,
-			"message": "Host is still unreachable",
+			"message": "Host is still unreachable.",
 		})
 	}
 

internals/server/server.go

@@ -14,9 +14,9 @@ func Handle() http.Handler {
     mux.HandleFunc("/ws", websocketHandler)
 
 	final := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		mux.ServeHTTP(w, r)
-
 		logger.Info(r.Method, " ", r.URL.Path, " ", r.URL.RawQuery)
+
+		mux.ServeHTTP(w, r)
 	})
 
 	return final

internals/server/websocket.go

@@ -14,10 +14,10 @@ var upgrader = websocket.Upgrader{
 	CheckOrigin: func(r *http.Request) bool { return true },
 }
 
-var waiters = make(map[string]chan *websocket.Conn)
+var waiters = map[string]chan *websocket.Conn{}
 var waitersMutex = &sync.Mutex{}
 
-var clients = make(map[string]*websocket.Conn)
+var clients = map[string]*websocket.Conn{}
 var clientsMutex = &sync.Mutex{}
 
 func websocketHandler(w http.ResponseWriter, req *http.Request) {
@@ -59,10 +59,14 @@ func register(req *http.Request, socket *websocket.Conn) string {
 	clientsMutex.Lock()
 	clients[clientID] = socket
 	clientsMutex.Unlock()
-	waitersMutex.Lock()
-	if ch, ok := waiters[clientID]; ok {
-		ch <- socket
 
+	waitersMutex.Lock()
+	ch, ok := waiters[clientID]
+	if ok {
+		select {
+		case ch <- socket:
+		default:
+		}
 		close(ch)
 		delete(waiters, clientID)
 	}
@@ -72,24 +76,31 @@ func register(req *http.Request, socket *websocket.Conn) string {
 }
 
 func waitForClient(clientID string, timeout time.Duration) (*websocket.Conn, error) {
-	waitCh := make(chan *websocket.Conn, 1)
-
-	waitersMutex.Lock()
-	waiters[clientID] = waitCh
-	waitersMutex.Unlock()
-
-	select {
-	case conn := <-waitCh:
-		return conn, nil
-	case <-time.After(timeout):
-		waitersMutex.Lock()
-		delete(waiters, clientID)
-		waitersMutex.Unlock()
-		return nil, errors.New("Timed out waiting for client")
-	}
+    clientsMutex.Lock()
+	conn, ok := clients[clientID]
+    if ok {
+        clientsMutex.Unlock()
+        return conn, nil
+    }
+    clientsMutex.Unlock()
+
+    waitCh := make(chan *websocket.Conn, 1)
+
+    waitersMutex.Lock()
+    waiters[clientID] = waitCh
+    waitersMutex.Unlock()
+
+    select {
+    case conn := <-waitCh:
+        return conn, nil
+    case <-time.After(timeout):
+        waitersMutex.Lock()
+        delete(waiters, clientID)
+        waitersMutex.Unlock()
+        return nil, errors.New("Timed out waiting for client")
+    }
 }
 
-
 func sendToClient(client *websocket.Conn, data map[string]any) error {
 	return client.WriteJSON(data)
 }

internals/wol/wol.go

@@ -1,6 +1,7 @@
 package wol
 
 import (
+	"errors"
 	"net"
 
 	"github.com/codeshelldev/gotl/pkg/logger"
@@ -19,7 +20,12 @@ func Init() {
 }
 
 func Wake(addr, mac string) error {
-	return client.Wake(addr, net.HardwareAddr(mac))
+	hwAddr, err := net.ParseMAC(mac)
+	if err != nil {
+		return errors.New("Could not parse mac: " + mac)
+	}
+	return client.Wake(addr, hwAddr)
+
 }
 
 func Close() {