proyectos/move-data-nas
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bump version to 1.0.9

Browse Source 
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.
This commit is contained in:
Daniel Arroyo
2026-07-08 19:19:50 -04:00
parent 25a31af64c
commit 5d5b6c99a7
13 changed files with 280 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/api/handlers_machines.go
+38 -1
View File
@@ -10,6 +10,7 @@ import (
"github.com/go-chi/chi/v5"
"github.com/syncserver/internal/models"
"github.com/syncserver/internal/wol"
)
type MachineHandler struct {
@@ -74,7 +75,7 @@ func (h *MachineHandler) Create(w http.ResponseWriter, r *http.Request) {
req.SSHUser = "root"
}
if req.WakeTimeoutSeconds <= 0 {
req.WakeTimeoutSeconds = 120
req.WakeTimeoutSeconds = 180
}
if req.WakeCheckIntervalSeconds <= 0 {
req.WakeCheckIntervalSeconds = 5
@@ -172,6 +173,42 @@ func (h *MachineHandler) Update(w http.ResponseWriter, r *http.Request) {
writeJSON(w, machineToResp(*existing))
}
func (h *MachineHandler) TestWoL(w http.ResponseWriter, r *http.Request) {
id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
if err != nil {
writeError(w, http.StatusBadRequest, "invalid id")
return
}
repo := models.NewMachineRepository(h.db)
m, err := repo.GetByID(id)
if err == sql.ErrNoRows {
writeError(w, http.StatusNotFound, "machine not found")
return
}
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to fetch machine")
return
}
if !m.WoLEnabled || m.MACAddress == nil {
writeError(w, http.StatusBadRequest, "WoL is not enabled for this machine or MAC address is missing")
return
}
mac, err := wol.ParseMAC(*m.MACAddress)
if err != nil {
writeError(w, http.StatusBadRequest, "invalid MAC address")
return
}
bcast := ""
if m.BroadcastAddr != nil {
bcast = *m.BroadcastAddr
}
if err := wol.Send(mac, bcast); err != nil {
writeError(w, http.StatusBadRequest, err.Error())
return
}
writeJSON(w, map[string]interface{}{"ok": true, "sent": 3})
}
func (h *MachineHandler) Delete(w http.ResponseWriter, r *http.Request) {
id, err := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
if err != nil {
internal/api/router.go
+1
View File
@@ -52,6 +52,7 @@ func NewServer(cfg *config.Config, db *sql.DB, engine *syncengine.Engine) *Serve
r.Get("/{id}", machineHandler.Get)
r.Put("/{id}", machineHandler.Update)
r.Delete("/{id}", machineHandler.Delete)
r.Post("/{id}/test-wol", machineHandler.TestWoL)
})
r.With(auth.RequireAuth).Route("/sync-pairs", func(r chi.Router) {
internal/syncengine/engine.go
+14 -8
View File
@@ -136,20 +136,26 @@ func (e *Engine) Run(ctx context.Context, jobID int64, pairID int64) error {
if targetMachine.BroadcastAddr != nil {
bcast = *targetMachine.BroadcastAddr
}
if err := wol.Send(targetMachine.Host, mac, bcast); err != nil {
slog.Warn("WoL failed", "host", targetMachine.Host, "error", err)
wolErr := wol.Send(mac, bcast)
if wolErr != nil {
slog.Warn("WoL send failed", "host", targetMachine.Host, "error", wolErr)
} else {
slog.Info("WoL magic packet sent", "host", targetMachine.Host, "mac", *targetMachine.MACAddress)
}
timeout := time.Duration(targetMachine.WakeTimeoutSeconds) * time.Second
interval := time.Duration(targetMachine.WakeCheckIntervalSeconds) * time.Second
if err := wol.WaitUntilReady(jobCtx, targetMachine.Host, remotePort, timeout, interval, false); err != nil {
e.setJobStatus(jobID, "failed")
e.setJobError(jobID, "wol_timeout", err.Error())
e.emit(Event{Type: "status", JobID: jobID, Key: "status", Value: "failed", Line: err.Error()})
return fmt.Errorf("machine not ready: %w", err)
}
if err := wol.WaitUntilReady(jobCtx, targetMachine.Host, remotePort, timeout, interval); err != nil {
e.setJobStatus(jobID, "failed")
if wolErr != nil {
e.setJobError(jobID, "wol_send_failed", wolErr.Error())
e.emit(Event{Type: "status", JobID: jobID, Key: "status", Value: "failed", Line: fmt.Sprintf("WoL send failed: %v", wolErr)})
return fmt.Errorf("WoL send failed: %w", wolErr)
}
e.setJobError(jobID, "wol_timeout", err.Error())
e.emit(Event{Type: "status", JobID: jobID, Key: "status", Value: "failed", Line: err.Error()})
return fmt.Errorf("machine not ready: %w", err)
}
}
}
internal/wol/waiter.go
+1 -22
View File
@@ -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
}
internal/wol/wol.go
+27 -8
View File
@@ -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
}
internal/wol/wol_test.go
+101 -2
View File
@@ -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:
}
}