Bump version to 1.0.9

Fix Wake-on-LAN: set SO_BROADCAST on UDP socket, send 3 magic packets, expose broadcast_addr and wake timeout fields in UI, add Test Wake endpoint, surface send errors in job status, bump default wake timeout to 180s.
2026-07-08 19:19:50 -04:00
parent 25a31af64c
commit 5d5b6c99a7
13 changed files with 280 additions and 48 deletions
@@ -4,13 +4,12 @@ import (
 	"context"
 	"fmt"
 	"net"
-	"os/exec"
 	"time"
 )

 var ErrTimeout = fmt.Errorf("timeout waiting for machine to respond")

-func WaitUntilReady(ctx context.Context, host string, sshPort int, maxWait, checkInterval time.Duration, usePing bool) error {
+func WaitUntilReady(ctx context.Context, host string, sshPort int, maxWait, checkInterval time.Duration) error {
 	deadline := time.Now().Add(maxWait)
 	interval := checkInterval

@@ -32,13 +31,6 @@ func WaitUntilReady(ctx context.Context, host string, sshPort int, maxWait, chec
 			return nil
 		}

-		if usePing {
-			cmd := exec.CommandContext(ctx, "ping", "-c", "1", "-W", "1", host)
-			if err := cmd.Run(); err == nil {
-				return nil
-			}
-		}
-
 		if time.Now().After(deadline) {
 			return ErrTimeout
 		}
@@ -53,16 +45,3 @@ func WaitUntilReady(ctx context.Context, host string, sshPort int, maxWait, chec
 		}
 	}
 }
-
-func IsHostReachable(host string, port int, timeout time.Duration) bool {
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-	addr := fmt.Sprintf("%s:%d", host, port)
-	dialer := net.Dialer{Timeout: timeout}
-	conn, err := dialer.DialContext(ctx, "tcp", addr)
-	if err == nil {
-		conn.Close()
-		return true
-	}
-	return false
-}
@@ -5,6 +5,7 @@ import (
 	"net"
 	"regexp"
 	"strings"
+	"syscall"
 	"time"
 )

@@ -45,7 +46,7 @@ func BuildMagicPacket(mac [6]byte) []byte {
 	return packet
 }

-func Send(addr string, mac [6]byte, broadcastAddr string) error {
+func Send(mac [6]byte, broadcastAddr string) error {
 	packet := BuildMagicPacket(mac)

 	udpAddr := &net.UDPAddr{
@@ -65,16 +66,34 @@ func Send(addr string, mac [6]byte, broadcastAddr string) error {
 	}
 	defer conn.Close()

+	sc, err := conn.SyscallConn()
+	if err != nil {
+		return fmt.Errorf("getting syscall conn: %w", err)
+	}
+	var setErr error
+	if err := sc.Control(func(fd uintptr) {
+		setErr = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1)
+	}); err != nil {
+		return fmt.Errorf("calling control: %w", err)
+	}
+	if setErr != nil {
+		return fmt.Errorf("enabling broadcast: %w", setErr)
+	}
 	if err := conn.SetWriteDeadline(time.Now().Add(5 * time.Second)); err != nil {
-		return fmt.Errorf("setting broadcast mode: %w", err)
+		return fmt.Errorf("setting write deadline: %w", err)
 	}

-	n, err := conn.Write(packet)
-	if err != nil {
-		return fmt.Errorf("sending magic packet: %w", err)
-	}
-	if n != len(packet) {
-		return fmt.Errorf("incomplete write: sent %d/%d bytes", n, len(packet))
+	for i := 0; i < 3; i++ {
+		n, err := conn.Write(packet)
+		if err != nil {
+			return fmt.Errorf("sending magic packet: %w", err)
+		}
+		if n != len(packet) {
+			return fmt.Errorf("incomplete write: sent %d/%d bytes", n, len(packet))
+		}
+		if i < 2 {
+			time.Sleep(100 * time.Millisecond)
+		}
 	}
 	return nil
 }
@@ -1,13 +1,16 @@
 package wol

 import (
+	"net"
+	"syscall"
 	"testing"
+	"time"
 )

 func TestParseMAC(t *testing.T) {
 	tests := []struct {
-		input    string
-		wantOK   bool
+		input     string
+		wantOK    bool
 		wantBytes [6]byte
 	}{
 		{"AA:BB:CC:DD:EE:FF", true, [6]byte{0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF}},
@@ -70,3 +73,99 @@ func TestBuildMagicPacket(t *testing.T) {
 		}
 	}
 }
+
+func TestSendInvalidBroadcast(t *testing.T) {
+	mac, _ := ParseMAC("aa:bb:cc:dd:ee:ff")
+	err := Send(mac, "not-an-ip")
+	if err == nil {
+		t.Error("Send with invalid broadcast address expected error, got nil")
+	}
+}
+
+func TestSendThreePacketsToListener(t *testing.T) {
+	mac, _ := ParseMAC("aa:bb:cc:dd:ee:ff")
+	ln, err := net.ListenPacket("udp", "127.0.0.1:9")
+	if err != nil {
+		t.Skipf("skipping test (need port 9, likely requires root): %v", err)
+	}
+	defer ln.Close()
+
+	err = Send(mac, "127.0.0.1")
+	if err != nil {
+		t.Errorf("Send to 127.0.0.1: expected nil, got %v", err)
+	}
+}
+
+func TestSendPacketReceived(t *testing.T) {
+	mac, _ := ParseMAC("aa:bb:cc:dd:ee:ff")
+	ln, err := net.ListenPacket("udp", "127.0.0.1:0")
+	if err != nil {
+		t.Skipf("skipping receive test: %v", err)
+	}
+	defer ln.Close()
+	addr := ln.LocalAddr().(*net.UDPAddr)
+
+	deadline := time.Now().Add(5 * time.Second)
+	errCh := make(chan error, 1)
+	go func() {
+		time.Sleep(500 * time.Millisecond)
+		conn, err := net.DialUDP("udp4", nil, &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: addr.Port})
+		if err != nil {
+			errCh <- err
+			return
+		}
+		sc, err := conn.SyscallConn()
+		if err != nil {
+			conn.Close()
+			errCh <- err
+			return
+		}
+		if err := sc.Control(func(fd uintptr) {
+			err = syscall.SetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1)
+		}); err != nil {
+			conn.Close()
+			errCh <- err
+			return
+		}
+		conn.SetWriteDeadline(time.Now().Add(3 * time.Second))
+		packet := BuildMagicPacket(mac)
+		for i := 0; i < 3; i++ {
+			conn.Write(packet)
+			time.Sleep(100 * time.Millisecond)
+		}
+		conn.Close()
+		errCh <- nil
+	}()
+
+	expected := BuildMagicPacket(mac)
+	buf := make([]byte, 102)
+	rcvd := 0
+	for rcvd < 3 {
+		ln.SetReadDeadline(deadline)
+		n, _, err := ln.ReadFrom(buf)
+		if err != nil {
+			if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+				break
+			}
+			t.Fatalf("unexpected error reading packet %d: %v", rcvd+1, err)
+		}
+		if n != len(expected) {
+			t.Errorf("packet %d: got length %d, want %d", rcvd+1, n, len(expected))
+			continue
+		}
+		if string(buf[:n]) != string(expected[:n]) {
+			t.Errorf("packet %d content mismatch", rcvd+1)
+		}
+		rcvd++
+	}
+	if rcvd != 3 {
+		t.Errorf("expected 3 packets, received %d", rcvd)
+	}
+	select {
+	case sendErr := <-errCh:
+		if sendErr != nil {
+			t.Logf("sender goroutine error (ignored): %v", sendErr)
+		}
+	default:
+	}
+}