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>
This commit is contained in:
Martino Ferrari
+1
-1
@@ -474,7 +474,7 @@ func (h *Hub) Run() {
|
||||
|
||||
case "wsAddSource":
|
||||
if h.sm != nil {
|
||||
go func(label, addr string) { h.sm.Add(label, addr) }(cmd.label, cmd.addr)
|
||||
go func(label, addr string) { h.sm.Add(label, addr, "", 0) }(cmd.label, cmd.addr)
|
||||
}
|
||||
|
||||
case "wsRemoveSource":
|
||||
|
||||
@@ -44,7 +44,7 @@ func main() {
|
||||
}
|
||||
for _, arg := range sourceArgs {
|
||||
label, addr := ParseSourceArg(arg)
|
||||
sm.Add(label, addr)
|
||||
sm.Add(label, addr, "", 0)
|
||||
}
|
||||
|
||||
sub, err := fs.Sub(staticFiles, "static")
|
||||
|
||||
+26
-11
@@ -11,16 +11,20 @@ import (
|
||||
|
||||
// SourceConfig is the serialisable description of one data source (for file save/load).
|
||||
type SourceConfig struct {
|
||||
Label string `json:"label"`
|
||||
Addr string `json:"addr"`
|
||||
Label string `json:"label"`
|
||||
Addr string `json:"addr"`
|
||||
MulticastGroup string `json:"multicastGroup,omitempty"` // "" = unicast mode
|
||||
DataPort int `json:"dataPort,omitempty"` // 0 = Addr port+1
|
||||
}
|
||||
|
||||
// managedSource is the SourceManager's view of one running source.
|
||||
type managedSource struct {
|
||||
id string
|
||||
label string
|
||||
addr string
|
||||
client *UDPClient
|
||||
id string
|
||||
label string
|
||||
addr string
|
||||
multicastGroup string
|
||||
dataPort int
|
||||
client *UDPClient
|
||||
}
|
||||
|
||||
// SourceManager owns the lifecycle of all active data sources.
|
||||
@@ -48,14 +52,20 @@ func (sm *SourceManager) genID() string {
|
||||
}
|
||||
|
||||
// Add creates a new source, registers it in the hub, and starts connecting.
|
||||
// multicastGroup: multicast IP (e.g. "239.0.0.1") or "" for unicast mode.
|
||||
// dataPort: UDP data port in multicast mode; 0 = Addr port+1.
|
||||
// Returns the source ID.
|
||||
func (sm *SourceManager) Add(label, addr string) string {
|
||||
func (sm *SourceManager) Add(label, addr, multicastGroup string, dataPort int) string {
|
||||
if label == "" {
|
||||
label = addr
|
||||
}
|
||||
id := sm.genID()
|
||||
c := NewUDPClient(addr, id, sm.hub)
|
||||
ms := &managedSource{id: id, label: label, addr: addr, client: c}
|
||||
c := NewUDPClient(addr, id, sm.hub, multicastGroup, dataPort)
|
||||
ms := &managedSource{
|
||||
id: id, label: label, addr: addr,
|
||||
multicastGroup: multicastGroup, dataPort: dataPort,
|
||||
client: c,
|
||||
}
|
||||
|
||||
sm.mu.Lock()
|
||||
sm.sources[id] = ms
|
||||
@@ -90,7 +100,12 @@ func (sm *SourceManager) Save() error {
|
||||
sm.mu.RLock()
|
||||
cfgs := make([]SourceConfig, 0, len(sm.sources))
|
||||
for _, ms := range sm.sources {
|
||||
cfgs = append(cfgs, SourceConfig{Label: ms.label, Addr: ms.addr})
|
||||
cfgs = append(cfgs, SourceConfig{
|
||||
Label: ms.label,
|
||||
Addr: ms.addr,
|
||||
MulticastGroup: ms.multicastGroup,
|
||||
DataPort: ms.dataPort,
|
||||
})
|
||||
}
|
||||
sm.mu.RUnlock()
|
||||
|
||||
@@ -113,7 +128,7 @@ func (sm *SourceManager) Load(path string) error {
|
||||
}
|
||||
sm.filePath = path
|
||||
for _, cfg := range cfgs {
|
||||
sm.Add(cfg.Label, cfg.Addr)
|
||||
sm.Add(cfg.Label, cfg.Addr, cfg.MulticastGroup, cfg.DataPort)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
+184
-12
@@ -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:
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user