Add TCP control + UDP multicast mode to UDPStreamer

DataSource (C++): - New optional config: MulticastGroup (e.g. "239.0.0.1") and DataPort (default Port+1); when set, enables multicast mode; absent = unicast - Control plane: BasicTCPSocket listener on Port; CONNECT received over TCP triggers HandleTCPConnect() which sends CONFIG via the same TCP connection - Data plane: BasicUDPSocket aimed at MulticastGroup:DataPort; all DATA fragments sent via dataSocket.Write() so any joined client receives them - useMulticast is the single branch point; every unicast code path is unchanged when MulticastGroup is absent - New methods: HandleTCPConnect(), IsMulticast() - 5 new unit tests (ports 44710-44729); all 38 tests passing WebUI hub (Go): - SourceConfig gains MulticastGroup and DataPort fields (JSON, optional) - UDPClient gains multicastGroup/dataPort; Run() routes to new runMulticastSession() when multicastGroup is non-empty - runMulticastSession(): TCP dial for CONNECT/CONFIG, net.ListenMulticastUDP for DATA, background goroutine watches TCP for DISCONNECT/close - All existing sm.Add() call sites updated (unicast callers pass "", 0) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-26 22:56:27 +02:00
parent f85ab8652c
commit b15e637f14
9 changed files with 864 additions and 58 deletions
@@ -1,8 +1,10 @@
 package main

 import (
+	"io"
 	"log"
 	"net"
+	"strconv"
 	"time"
 )

@@ -13,22 +15,31 @@ const (
 	udpRcvBufSize  = 8 * 1024 * 1024 // 8 MB OS receive buffer — absorbs bursts at high data rates
 )

-// UDPClient manages the UDP connection to one MARTe2 streamer source.
+// UDPClient manages the connection to one MARTe2 streamer source.
+// In unicast mode (multicastGroup == "") it uses a single UDP socket for control and data.
+// In multicast mode it uses TCP for control (CONNECT/CONFIG/DISCONNECT) and
+// joins a UDP multicast group to receive DATA packets.
 type UDPClient struct {
-	serverAddr string
-	sourceID   string
-	hub        *Hub
+	serverAddr     string
+	sourceID       string
+	hub            *Hub
+	multicastGroup string // "" = unicast mode
+	dataPort       int    // UDP data port in multicast mode; 0 = serverAddr port+1

 	stopCh chan struct{}
 }

 // NewUDPClient creates a UDPClient bound to a specific source ID. Call Run() in a goroutine.
-func NewUDPClient(serverAddr, sourceID string, hub *Hub) *UDPClient {
+// multicastGroup: multicast IP (e.g. "239.0.0.1") or "" for unicast.
+// dataPort: UDP data port; 0 = serverAddr port+1.
+func NewUDPClient(serverAddr, sourceID string, hub *Hub, multicastGroup string, dataPort int) *UDPClient {
 	return &UDPClient{
-		serverAddr: serverAddr,
-		sourceID:   sourceID,
-		hub:        hub,
-		stopCh:     make(chan struct{}),
+		serverAddr:     serverAddr,
+		sourceID:       sourceID,
+		hub:            hub,
+		multicastGroup: multicastGroup,
+		dataPort:       dataPort,
+		stopCh:         make(chan struct{}),
 	}
 }

@@ -47,10 +58,16 @@ func (u *UDPClient) Run() {
 		}

 		u.hub.SetSourceState(u.sourceID, "connecting")
-		log.Printf("[%s] udp: connecting to %s", u.sourceID, u.serverAddr)
-		err := u.runSession()
+		log.Printf("[%s] connecting to %s", u.sourceID, u.serverAddr)
+
+		var err error
+		if u.multicastGroup != "" {
+			err = u.runMulticastSession()
+		} else {
+			err = u.runSession()
+		}
 		if err != nil {
-			log.Printf("[%s] udp: session ended: %v", u.sourceID, err)
+			log.Printf("[%s] session ended: %v", u.sourceID, err)
 		}
 		u.hub.SetSourceState(u.sourceID, "disconnected")

@@ -165,3 +182,158 @@ func (u *UDPClient) runSession() error {
 		}
 	}
 }
+
+// runMulticastSession handles the multicast mode session:
+//   - TCP connection to serverAddr for control (CONNECT → CONFIG, DISCONNECT)
+//   - UDP multicast socket joined to multicastGroup:dataPort for DATA packets
+func (u *UDPClient) runMulticastSession() error {
+	// 1. Resolve TCP control address
+	tcpAddr, err := net.ResolveTCPAddr("tcp4", u.serverAddr)
+	if err != nil {
+		return err
+	}
+
+	// 2. Dial TCP control connection
+	tcpConn, err := net.DialTCP("tcp4", nil, tcpAddr)
+	if err != nil {
+		return err
+	}
+	defer tcpConn.Close()
+
+	// 3. Send CONNECT via TCP
+	if _, err := tcpConn.Write(BuildConnectPacket()); err != nil {
+		return err
+	}
+	log.Printf("[%s] tcp: sent CONNECT to %s", u.sourceID, u.serverAddr)
+
+	// 4. Read CONFIG header via TCP (io.ReadFull to handle partial reads)
+	hdrBuf := make([]byte, HeaderSize)
+	if _, err := io.ReadFull(tcpConn, hdrBuf); err != nil {
+		return err
+	}
+	cfgHdr, err := ParseHeader(hdrBuf)
+	if err != nil {
+		return err
+	}
+	if cfgHdr.Type != PktConfig {
+		return net.ErrClosed // unexpected packet type
+	}
+	cfgPayload := make([]byte, cfgHdr.PayloadBytes)
+	if cfgHdr.PayloadBytes > 0 {
+		if _, err := io.ReadFull(tcpConn, cfgPayload); err != nil {
+			return err
+		}
+	}
+	currentSigs, err := ParseConfig(cfgPayload)
+	if err != nil {
+		return err
+	}
+	log.Printf("[%s] tcp: received CONFIG (%d signals)", u.sourceID, len(currentSigs))
+	u.hub.SetSourceState(u.sourceID, "connected")
+	u.hub.UpdateConfigForSource(u.sourceID, currentSigs)
+
+	// 5. Determine multicast data port (dataPort or serverAddr port+1)
+	mcastPort := u.dataPort
+	if mcastPort == 0 {
+		mcastPort = tcpAddr.Port + 1
+	}
+
+	// 6. Join multicast group for DATA
+	mcastIP := net.ParseIP(u.multicastGroup)
+	if mcastIP == nil {
+		return &net.AddrError{Err: "invalid multicast group IP", Addr: u.multicastGroup}
+	}
+	mcastAddr := &net.UDPAddr{IP: mcastIP, Port: mcastPort}
+	mcastConn, err := net.ListenMulticastUDP("udp4", nil, mcastAddr)
+	if err != nil {
+		return err
+	}
+	defer mcastConn.Close()
+	if err := mcastConn.SetReadBuffer(udpRcvBufSize); err != nil {
+		log.Printf("[%s] multicast SetReadBuffer: %v", u.sourceID, err)
+	}
+	log.Printf("[%s] joined multicast %s:%s", u.sourceID, u.multicastGroup,
+		strconv.Itoa(mcastPort))
+
+	// 7. Background goroutine: watch TCP conn for DISCONNECT or closure
+	tcpDone := make(chan error, 1)
+	go func() {
+		buf := make([]byte, HeaderSize+64)
+		for {
+			n, readErr := tcpConn.Read(buf)
+			if readErr != nil {
+				tcpDone <- readErr
+				return
+			}
+			if n >= HeaderSize {
+				hdr, parseErr := ParseHeader(buf[:n])
+				if parseErr == nil && hdr.Type == PktDisconnect {
+					tcpDone <- nil
+					return
+				}
+			}
+		}
+	}()
+
+	// 8. Main loop: receive DATA packets from multicast group
+	reassembler := NewReassembler(2 * time.Second)
+	buf := make([]byte, readBufSize)
+
+	for {
+		mcastConn.SetReadDeadline(time.Now().Add(silenceTimeout))
+		n, _, readErr := mcastConn.ReadFromUDP(buf)
+		arrivalTime := time.Now()
+		if readErr != nil {
+			select {
+			case <-tcpDone:
+				return nil
+			default:
+			}
+			tcpConn.Write(BuildDisconnectPacket())
+			return readErr
+		}
+
+		if n < HeaderSize {
+			continue
+		}
+		hdr, parseErr := ParseHeader(buf[:n])
+		if parseErr != nil {
+			log.Printf("[%s] multicast: parse header: %v", u.sourceID, parseErr)
+			continue
+		}
+
+		payload := make([]byte, n-HeaderSize)
+		copy(payload, buf[HeaderSize:n])
+
+		complete, ok := reassembler.AddFragment(hdr, payload)
+		if hdr.Type == PktData {
+			u.hub.RecordDataFragment(u.sourceID, hdr.Counter, n,
+				arrivalTime.UnixNano(), ok)
+		}
+		if !ok {
+			continue
+		}
+
+		if hdr.Type == PktData {
+			if len(currentSigs) == 0 {
+				continue
+			}
+			sample, parseErr := ParseData(complete, currentSigs, arrivalTime)
+			if parseErr != nil {
+				log.Printf("[%s] multicast: parse data: %v", u.sourceID, parseErr)
+				continue
+			}
+			u.hub.PushDataForSource(u.sourceID, sample)
+		}
+
+		select {
+		case <-u.stopCh:
+			tcpConn.Write(BuildDisconnectPacket())
+			return nil
+		case tcpErr := <-tcpDone:
+			log.Printf("[%s] tcp control closed: %v", u.sourceID, tcpErr)
+			return nil
+		default:
+		}
+	}
+}