You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2026/08/19 14:47:22 UTC
(plc4x) 04/07: fix(plc4go/knxnetip): stop the discoverer leaking goroutines and sockets
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit b43730080bd103f90ba9aba92895f3d0e8d7bb20
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Wed Aug 19 16:28:50 2026 +0200
fix(plc4go/knxnetip): stop the discoverer leaking goroutines and sockets
Discovery registered its completion accounting when the per-interface runnable
was constructed but only released it when the runnable actually ran, and the
worker pool drops submitted work outright once the context is done. A cancelled
discovery therefore left the wait group permanently short: the channel of
transport instances was never closed, its consumer leaked, and Close blocked
forever waiting on all of it, taking the driver's Close with it.
Completion no longer depends on the pool executing the work. The codec opened
per interface is disconnected on every path rather than left running with its
socket, the send of a transport instance selects on the context instead of
blocking on an unbuffered channel, and the search-response type assertion is
checked so a foreign frame cannot panic the receive worker.
---
plc4go/internal/knxnetip/Discoverer.go | 390 +++++++++++++++-------------
plc4go/internal/knxnetip/Discoverer_test.go | 274 +++++++++++++++++++
2 files changed, 488 insertions(+), 176 deletions(-)
diff --git a/plc4go/internal/knxnetip/Discoverer.go b/plc4go/internal/knxnetip/Discoverer.go
index cc5d3fa19d..57175d6abc 100644
--- a/plc4go/internal/knxnetip/Discoverer.go
+++ b/plc4go/internal/knxnetip/Discoverer.go
@@ -27,53 +27,60 @@ import (
"net/url"
"runtime/debug"
"sync"
- "sync/atomic"
"time"
"github.com/rs/zerolog"
apiModel "github.com/apache/plc4x/plc4go/pkg/api/model"
driverModel "github.com/apache/plc4x/plc4go/protocols/knxnetip/readwrite/model"
- "github.com/apache/plc4x/plc4go/spi/errors"
+ "github.com/apache/plc4x/plc4go/spi"
spiModel "github.com/apache/plc4x/plc4go/spi/model"
"github.com/apache/plc4x/plc4go/spi/options"
- "github.com/apache/plc4x/plc4go/spi/pool"
- "github.com/apache/plc4x/plc4go/spi/transports"
"github.com/apache/plc4x/plc4go/spi/transports/udp"
"github.com/apache/plc4x/plc4go/spi/utils"
)
-type Discoverer struct {
- transportInstanceCreationWorkItemId atomic.Int32
- transportInstanceCreationQueue pool.Executor
- deviceScanningWorkItemId atomic.Int32
- deviceScanningQueue pool.Executor
+// knxMulticastDiscoveryUrl is the KNXnet/IP system-setup multicast address all
+// KNXnet/IP routers/interfaces listen on for SearchRequests.
+const knxMulticastDiscoveryUrl = "udp://224.0.23.12:3671"
+
+// discoveryWindow is how long each per-address scan waits for SearchResponses
+// to arrive after sending the SearchRequest.
+// TODO: Make this configurable
+const discoveryWindow = 5 * time.Second
+// discoveryReceiveTick bounds how long a single receive waits before the scan
+// loop re-checks the context and the overall discovery window.
+const discoveryReceiveTick = 1 * time.Second
+
+type Discoverer struct {
wg sync.WaitGroup // use to track spawned go routines
+ // closeCtx is cancelled by Close, which aborts all in-flight scans instead
+ // of making Close block for the remainder of their discovery window.
+ closeCtx context.Context
+ closeCancel context.CancelFunc
+
log zerolog.Logger
_options []options.WithOption // Used to pass them downstream
}
func NewDiscoverer(_options ...options.WithOption) *Discoverer {
customLogger := options.ExtractCustomLoggerOrDefaultToGlobal(_options...)
+ closeCtx, closeCancel := context.WithCancel(context.Background())
return &Discoverer{
- // TODO: maybe a dynamic executor would be better to not waste cycles when not in use
- transportInstanceCreationQueue: pool.NewFixedSizeExecutor(50, 100, _options...),
- deviceScanningQueue: pool.NewFixedSizeExecutor(50, 100, _options...),
- log: customLogger,
- _options: _options,
+ closeCtx: closeCtx,
+ closeCancel: closeCancel,
+ log: customLogger,
+ _options: _options,
}
}
func (d *Discoverer) Discover(ctx context.Context, callback func(event apiModel.PlcDiscoveryItem), discoveryOptions ...options.WithDiscoveryOption) error {
- d.transportInstanceCreationQueue.Start()
- d.deviceScanningQueue.Start()
-
udpTransport := udp.NewTransport()
// Create a connection string for the KNX broadcast discovery address.
- connectionUrl, err := url.Parse("udp://224.0.23.12:3671")
+ connectionUrl, err := url.Parse(knxMulticastDiscoveryUrl)
if err != nil {
return err
}
@@ -107,198 +114,229 @@ func (d *Discoverer) Discover(ctx context.Context, callback func(event apiModel.
interfaces = allInterfaces
}
- transportInstances := make(chan transports.TransportInstance)
- wg := &sync.WaitGroup{}
- // Iterate over all network devices of this system.
+ // Every scan runs on a context derived from the caller's context which is
+ // additionally cancelled by Close. The AfterFunc registration is released
+ // again as soon as all scans of this Discover call are done, so neither the
+ // caller's context nor closeCtx accumulate registrations over time.
+ closeCtx := d.closeCtx
+ if closeCtx == nil {
+ closeCtx = context.Background()
+ }
+ scanCtx, cancelScans := context.WithCancel(ctx)
+ stopCloseHook := context.AfterFunc(closeCtx, cancelScans)
+
+ // scanWg only tracks the scans of this Discover call, d.wg tracks it in turn
+ // so that Close waits for everything without any accounting living inside
+ // the scan goroutines themselves.
+ scanWg := &sync.WaitGroup{}
+ // Iterate over all network devices of this system. A failure on one of them has to
+ // leave the loop through scanErr instead of returning right away: the scans which
+ // already were started are only covered by Close once the d.wg.Go below registered
+ // the waiter, so an early return would leak them out of the "Close waits for
+ // everything" guarantee.
+ var scanErr error
for _, netInterface := range interfaces {
if err := ctx.Err(); err != nil {
- return err
+ scanErr = err
+ break
}
addrs, err := netInterface.Addrs()
if err != nil {
- return err
+ scanErr = err
+ break
}
- wg.Go(func() {
- defer func() {
- if err := recover(); err != nil {
- d.log.Error().
- Str("stack", string(debug.Stack())).
- Interface("err", err).
- Msg("panic-ed")
- }
- }()
- // Iterate over all addresses the current interface has configured
- // For KNX we're only interested in IPv4 addresses, as it doesn't
- // seem to work with IPv6.
- for _, addr := range addrs {
- if err := ctx.Err(); err != nil {
- d.log.Debug().Err(err).Msg("done")
- return
- }
- var ipv4Addr net.IP
- switch addr.(type) {
- // If the device is configured to communicate with a subnet
- case *net.IPNet:
- ipv4Addr = addr.(*net.IPNet).IP.To4()
+ // Iterate over all addresses the current interface has configured
+ // For KNX we're only interested in IPv4 addresses, as it doesn't
+ // seem to work with IPv6.
+ for _, addr := range addrs {
+ var ipv4Addr net.IP
+ switch typedAddr := addr.(type) {
+ // If the device is configured to communicate with a subnet
+ case *net.IPNet:
+ ipv4Addr = typedAddr.IP.To4()
- // If the device is configured for a point-to-point connection
- case *net.IPAddr:
- ipv4Addr = addr.(*net.IPAddr).IP.To4()
- }
-
- // If we found an IPv4 address and this is not a loopback address,
- // add it to the list of devices we will open ports and send discovery
- // messages from.
- if ipv4Addr == nil || ipv4Addr.IsLoopback() {
- continue
- }
- d.transportInstanceCreationQueue.Submit(ctx, d.transportInstanceCreationWorkItemId.Add(1), d.createTransportInstanceDispatcher(ctx, wg, connectionUrl, ipv4Addr, udpTransport, transportInstances))
+ // If the device is configured for a point-to-point connection
+ case *net.IPAddr:
+ ipv4Addr = typedAddr.IP.To4()
}
- })
- }
- d.wg.Go(func() {
- wg.Wait()
- d.log.Trace().Msg("Closing transport instance channel")
- close(transportInstances)
- })
- d.wg.Go(func() {
- defer func() {
- if err := recover(); err != nil {
- d.log.Error().
- Str("stack", string(debug.Stack())).
- Interface("err", err).
- Msg("panic-ed")
- }
- }()
- for transportInstance := range transportInstances {
- if transportInstance == nil {
- d.log.Trace().Msg("channel closed")
- break
+ // If we found an IPv4 address and this is not a loopback address,
+ // add it to the list of devices we will open ports and send discovery
+ // messages from.
+ if ipv4Addr == nil || ipv4Addr.IsLoopback() {
+ continue
}
- d.deviceScanningQueue.Submit(ctx, d.deviceScanningWorkItemId.Add(1), d.createDeviceScanDispatcher(ctx, transportInstance.(*udp.TransportInstance), callback))
+ scanWg.Go(func() {
+ defer func() {
+ if err := recover(); err != nil {
+ d.log.Error().
+ Str("stack", string(debug.Stack())).
+ Interface("err", err).
+ Msg("panic-ed")
+ }
+ }()
+ d.scanAddress(scanCtx, connectionUrl, ipv4Addr, udpTransport, callback)
+ })
}
+ }
+ d.wg.Go(func() {
+ defer cancelScans()
+ defer stopCloseHook()
+ scanWg.Wait()
+ d.log.Trace().Msg("All scans done")
})
+ if scanErr != nil {
+ // Stop whatever already got started; the waiter above keeps tracking it, so
+ // Close still waits for those scans to actually finish.
+ cancelScans()
+ return scanErr
+ }
return nil
}
-func (d *Discoverer) createTransportInstanceDispatcher(ctx context.Context, wg *sync.WaitGroup, connectionUrl *url.URL, ipv4Addr net.IP, udpTransport *udp.Transport, transportInstances chan transports.TransportInstance) pool.Runnable {
- wg.Add(1)
- return func(workerCtx context.Context) {
- ctx, cancel := context.WithCancel(ctx)
- context.AfterFunc(workerCtx, cancel)
- defer wg.Done()
- // Create a new "connection" (Actually open a local udp socket and target outgoing packets to that address)
- transportInstance, err :=
- udpTransport.CreateTransportInstanceForLocalAddress(*connectionUrl, nil,
- &net.UDPAddr{IP: ipv4Addr, Port: 0})
- if err != nil {
- d.log.Error().Err(err).Msg("error creating transport instance")
- return
- }
- err = transportInstance.Connect(ctx)
- if err != nil {
- d.log.Debug().Err(err).Msg("Error Connecting")
- return
+// scanAddress opens one udp socket bound to the given local ipv4 address, sends
+// a SearchRequest to the KNXnet/IP discovery multicast address and reports every
+// SearchResponse it receives within the discovery window to callback.
+//
+// Every resource it acquires is released again before it returns, on all paths.
+func (d *Discoverer) scanAddress(ctx context.Context, connectionUrl *url.URL, ipv4Addr net.IP, udpTransport *udp.Transport, callback func(event apiModel.PlcDiscoveryItem)) {
+ if err := ctx.Err(); err != nil {
+ d.log.Debug().Err(err).Msg("done")
+ return
+ }
+ // Create a new "connection" (Actually open a local udp socket and target outgoing packets to that address)
+ transportInstance, err := udpTransport.CreateTransportInstanceForLocalAddress(*connectionUrl, nil,
+ &net.UDPAddr{IP: ipv4Addr, Port: 0})
+ if err != nil {
+ d.log.Error().Err(err).Msg("error creating transport instance")
+ return
+ }
+ udpTransportInstance, ok := transportInstance.(*udp.TransportInstance)
+ if !ok {
+ d.log.Error().Type("transportInstanceType", transportInstance).Msg("unexpected transport instance type")
+ if err := transportInstance.Close(); err != nil {
+ d.log.Debug().Err(err).Msg("error closing transport instance")
}
- d.log.Debug().Interface("transportInstance", transportInstance).Msg("Adding transport instance to scan %v")
- transportInstances <- transportInstance
+ return
}
-}
-func (d *Discoverer) createDeviceScanDispatcher(ctx context.Context, udpTransportInstance *udp.TransportInstance, callback func(event apiModel.PlcDiscoveryItem)) pool.Runnable {
- return func(workerCtx context.Context) {
- ctx, cancel := context.WithCancel(ctx)
- context.AfterFunc(workerCtx, cancel)
- d.log.Debug().Interface("udpTransportInstance", udpTransportInstance).Msg("Scanning")
- // Create a codec for sending and receiving messages.
- codec := NewMessageCodec(
- udpTransportInstance,
- nil,
- append(d._options, options.WithCustomLogger(d.log))...,
- )
- // Explicitly start the worker
- if err := codec.Connect(ctx); err != nil {
- d.log.Error().Err(err).Msg("Error connecting")
- return
+ d.log.Debug().Stringer("udpTransportInstance", udpTransportInstance).Msg("Scanning")
+ // Create a codec for sending and receiving messages.
+ codec := NewMessageCodec(
+ udpTransportInstance,
+ nil,
+ append(d._options, options.WithCustomLogger(d.log))...,
+ )
+ // Explicitly start the worker. This also connects the transport instance.
+ if err := codec.Connect(ctx); err != nil {
+ d.log.Error().Err(err).Msg("Error connecting")
+ // The codec never took ownership of the transport instance, so the socket
+ // (if it got opened at all) has to be closed here.
+ if err := udpTransportInstance.Close(); err != nil {
+ d.log.Debug().Err(err).Msg("error closing transport instance")
}
+ return
+ }
+ // Disconnecting stops the codecs receive worker and closes the udp socket.
+ defer func() {
+ if err := codec.Disconnect(); err != nil {
+ d.log.Debug().Err(err).Msg("error disconnecting codec")
+ }
+ }()
- localAddress := udpTransportInstance.LocalAddress
- localAddr := driverModel.NewIPAddress(localAddress.IP)
+ localAddress := udpTransportInstance.LocalAddress
+ localAddr := driverModel.NewIPAddress(localAddress.IP)
- // Prepare the discovery packet data
- discoveryEndpoint := driverModel.NewHPAIDiscoveryEndpoint(
- driverModel.HostProtocolCode_IPV4_UDP, localAddr, uint16(localAddress.Port))
- searchRequestMessage := driverModel.NewSearchRequest(discoveryEndpoint)
- // Send the search request.
- if err := codec.Send(ctx, "device_scan_search_request", searchRequestMessage); err != nil {
- d.log.Debug().Err(err).Interface("searchRequestMessage", searchRequestMessage).Msg("Error sending message")
- return
+ // Prepare the discovery packet data
+ discoveryEndpoint := driverModel.NewHPAIDiscoveryEndpoint(
+ driverModel.HostProtocolCode_IPV4_UDP, localAddr, uint16(localAddress.Port))
+ searchRequestMessage := driverModel.NewSearchRequest(discoveryEndpoint)
+ // Send the search request.
+ if err := codec.Send(ctx, "device_scan_search_request", searchRequestMessage); err != nil {
+ d.log.Debug().Err(err).Interface("searchRequestMessage", searchRequestMessage).Msg("Error sending message")
+ return
+ }
+
+ // Keep on reading responses till the discovery window is done.
+ timeout := time.NewTimer(discoveryReceiveTick)
+ defer timeout.Stop()
+ deadline := time.Now().Add(discoveryWindow)
+ for time.Now().Before(deadline) {
+ tick := discoveryReceiveTick
+ if remaining := time.Until(deadline); remaining < tick {
+ tick = remaining
}
- // Keep on reading responses till the timeout is done.
- // TODO: Make this configurable
- timeout := time.NewTimer(1 * time.Second)
- timeout.Stop()
- for start := time.Now(); time.Since(start) < time.Second*5; {
- if err := ctx.Err(); err != nil {
- d.log.Debug().Err(err).Msg("done")
- return
- }
- timeout.Reset(1 * time.Second)
+ if !timeout.Stop() {
select {
- case message := <-codec.GetDefaultIncomingMessageChannel():
- {
- if !timeout.Stop() {
- <-timeout.C
- }
- searchResponse := message.(driverModel.SearchResponse)
- if searchResponse != nil {
- addr := searchResponse.GetHpaiControlEndpoint().GetIpAddress().GetAddr()
- remoteUrl, err := url.Parse(fmt.Sprintf("udp://%d.%d.%d.%d:%d",
- addr[0], addr[1], addr[2], addr[3], searchResponse.GetHpaiControlEndpoint().GetIpPort()))
- if err != nil {
- continue
- }
- deviceName := string(bytes.Trim(searchResponse.GetDibDeviceInfo().GetDeviceFriendlyName(), "\x00"))
- discoveryEvent := spiModel.NewDefaultPlcDiscoveryItem(
- "knxnet-ip",
- "udp",
- *remoteUrl,
- nil,
- deviceName,
- nil,
- )
- // Pass the event back to the callback
- callback(discoveryEvent)
- }
- continue
- }
case <-timeout.C:
- {
- timeout.Stop()
- continue
- }
+ default:
+ }
+ }
+ timeout.Reset(tick)
+ select {
+ case <-ctx.Done():
+ d.log.Debug().Err(ctx.Err()).Msg("done")
+ return
+ case message := <-codec.GetDefaultIncomingMessageChannel():
+ discoveryItem, ok := d.discoveryItemFromMessage(message)
+ if !ok {
+ continue
}
+ // Pass the event back to the callback
+ callback(discoveryItem)
+ case <-timeout.C:
+ continue
}
}
}
+// discoveryItemFromMessage turns a received message into a discovery item. It
+// returns false for anything which isn't a usable SearchResponse.
+func (d *Discoverer) discoveryItemFromMessage(message spi.Message) (apiModel.PlcDiscoveryItem, bool) {
+ if message == nil {
+ return nil, false
+ }
+ searchResponse, ok := message.(driverModel.SearchResponse)
+ if !ok {
+ d.log.Debug().Type("messageType", message).Msg("unexpected message type")
+ return nil, false
+ }
+ controlEndpoint := searchResponse.GetHpaiControlEndpoint()
+ deviceInfo := searchResponse.GetDibDeviceInfo()
+ if controlEndpoint == nil || controlEndpoint.GetIpAddress() == nil || deviceInfo == nil {
+ d.log.Debug().Msg("incomplete search response")
+ return nil, false
+ }
+ addr := controlEndpoint.GetIpAddress().GetAddr()
+ if len(addr) < 4 {
+ d.log.Debug().Int("addrLength", len(addr)).Msg("unexpected address length")
+ return nil, false
+ }
+ remoteUrl, err := url.Parse(fmt.Sprintf("udp://%d.%d.%d.%d:%d",
+ addr[0], addr[1], addr[2], addr[3], controlEndpoint.GetIpPort()))
+ if err != nil {
+ d.log.Debug().Err(err).Msg("error building discovery url")
+ return nil, false
+ }
+ deviceName := string(bytes.Trim(deviceInfo.GetDeviceFriendlyName(), "\x00"))
+ return spiModel.NewDefaultPlcDiscoveryItem(
+ "knxnet-ip",
+ "udp",
+ *remoteUrl,
+ nil,
+ deviceName,
+ nil,
+ ), true
+}
+
func (d *Discoverer) Close() error {
defer utils.StopWarn(d.log)()
d.log.Trace().Msg("Closing discoverer")
- var collectedErrors []error
- d.log.Trace().Msg("Closing transport instance creation queue")
- if err := d.transportInstanceCreationQueue.Close(); err != nil {
- collectedErrors = append(collectedErrors, errors.Wrap(err, "error closing transport instance creation queue"))
- }
- d.log.Trace().Msg("Closing device scanning queue")
- if err := d.deviceScanningQueue.Close(); err != nil {
- collectedErrors = append(collectedErrors, errors.Wrap(err, "error closing device scanning queue"))
+ if d.closeCancel != nil {
+ d.log.Trace().Msg("Cancelling running scans")
+ d.closeCancel()
}
d.log.Trace().Msg("waiting for wait group")
d.wg.Wait()
- if err := errors.Join(collectedErrors...); err != nil {
- return errors.Wrap(err, "error closing discoverer")
- }
return nil
}
diff --git a/plc4go/internal/knxnetip/Discoverer_test.go b/plc4go/internal/knxnetip/Discoverer_test.go
new file mode 100644
index 0000000000..3d8cf0edfb
--- /dev/null
+++ b/plc4go/internal/knxnetip/Discoverer_test.go
@@ -0,0 +1,274 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package knxnetip
+
+import (
+ "context"
+ "net"
+ "runtime"
+ "sync/atomic"
+ "testing"
+ "time"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ apiModel "github.com/apache/plc4x/plc4go/pkg/api/model"
+ driverModel "github.com/apache/plc4x/plc4go/protocols/knxnetip/readwrite/model"
+ "github.com/apache/plc4x/plc4go/spi"
+ "github.com/apache/plc4x/plc4go/spi/options"
+ "github.com/apache/plc4x/plc4go/spi/testutils"
+)
+
+// closeTimeout is the budget a Discoverer.Close gets in the tests below. The
+// discovery window itself is 5s per scan, but Close cancels all in-flight scans,
+// so this is generous by design: it only has to catch a Close which hangs
+// forever (which is what an unbalanced WaitGroup used to produce).
+const closeTimeout = 30 * time.Second
+
+func testDiscoverer(t *testing.T) *Discoverer {
+ // Deliberately NOT testutils.EnrichOptionsWithOptionsForTesting: that one
+ // spins up an extra worker pool which would show up in the goroutine counts
+ // these tests compare.
+ return NewDiscoverer(options.WithCustomLogger(testutils.ProduceTestingLogger(t)))
+}
+
+// requireCloseWithin closes the discoverer and fails the test if Close doesn't
+// return within the given budget instead of blocking the test binary forever.
+func requireCloseWithin(t *testing.T, d *Discoverer, timeout time.Duration) {
+ t.Helper()
+ closed := make(chan error, 1)
+ go func() {
+ closed <- d.Close()
+ }()
+ select {
+ case err := <-closed:
+ require.NoError(t, err)
+ case <-time.After(timeout):
+ dumpGoroutines(t)
+ t.Fatalf("Close did not return within %s", timeout)
+ }
+}
+
+// assertNoGoroutineLeak checks that the number of running goroutines settles
+// back at (or below) the baseline. Goroutines the runtime tears down lazily
+// make a single sample flaky, hence the retries.
+func assertNoGoroutineLeak(t *testing.T, baseline int) {
+ t.Helper()
+ current := runtime.NumGoroutine()
+ for i := 0; i < 100 && current > baseline; i++ {
+ time.Sleep(50 * time.Millisecond)
+ current = runtime.NumGoroutine()
+ }
+ if current > baseline {
+ dumpGoroutines(t)
+ t.Fatalf("goroutine leak detected: baseline %d, now %d", baseline, current)
+ }
+}
+
+func dumpGoroutines(t *testing.T) {
+ t.Helper()
+ buf := make([]byte, 1<<20)
+ n := runtime.Stack(buf, true)
+ t.Logf("goroutine dump:\n%s", buf[:n])
+}
+
+// TestDiscovererDiscoverWithCanceledContext pins that a discovery started on an
+// already canceled context neither leaks goroutines nor makes Close hang.
+func TestDiscovererDiscoverWithCanceledContext(t *testing.T) {
+ baseline := runtime.NumGoroutine()
+
+ d := testDiscoverer(t)
+ ctx, cancel := context.WithCancel(context.Background())
+ cancel()
+
+ var callbackCalls atomic.Int32
+ if err := d.Discover(ctx, func(_ apiModel.PlcDiscoveryItem) { callbackCalls.Add(1) }); err != nil {
+ assert.ErrorIs(t, err, context.Canceled)
+ }
+ requireCloseWithin(t, d, closeTimeout)
+
+ assert.Zero(t, callbackCalls.Load(), "no discovery item can be found on a canceled context")
+ assertNoGoroutineLeak(t, baseline)
+}
+
+// TestDiscovererDiscoverWithExpiringContext runs a couple of discoveries whose
+// context expires while the scans are being set up. This is the shape which used
+// to strand the scan goroutines (work submitted to the worker pool was silently
+// dropped once the context was done, so the WaitGroup tracking it never reached
+// zero and Close blocked forever).
+func TestDiscovererDiscoverWithExpiringContext(t *testing.T) {
+ baseline := runtime.NumGoroutine()
+
+ for i := 0; i < 5; i++ {
+ d := testDiscoverer(t)
+ ctx, cancel := context.WithTimeout(context.Background(), 20*time.Millisecond)
+ if err := d.Discover(ctx, func(_ apiModel.PlcDiscoveryItem) {}); err != nil {
+ assert.ErrorIs(t, err, context.DeadlineExceeded)
+ }
+ requireCloseWithin(t, d, closeTimeout)
+ cancel()
+ }
+
+ assertNoGoroutineLeak(t, baseline)
+}
+
+// requireScannableInterface skips the test if this machine has no interface a scan could
+// run on. Without one the test would silently degrade into "Close with nothing to cancel",
+// which the other tests cover already.
+func requireScannableInterface(t *testing.T) {
+ t.Helper()
+ interfaces, err := net.Interfaces()
+ if err != nil {
+ t.Skipf("cannot enumerate the network interfaces: %v", err)
+ }
+ for _, netInterface := range interfaces {
+ addrs, err := netInterface.Addrs()
+ if err != nil {
+ continue
+ }
+ for _, addr := range addrs {
+ var ipv4Addr net.IP
+ switch typedAddr := addr.(type) {
+ case *net.IPNet:
+ ipv4Addr = typedAddr.IP.To4()
+ case *net.IPAddr:
+ ipv4Addr = typedAddr.IP.To4()
+ }
+ if ipv4Addr != nil && !ipv4Addr.IsLoopback() {
+ return
+ }
+ }
+ }
+ t.Skip("no non-loopback ipv4 interface to scan on")
+}
+
+// TestDiscovererCloseCancelsRunningDiscovery pins that Close aborts scans which
+// are still within their discovery window instead of waiting it out.
+//
+// Unlike the other tests here this one really opens udp sockets and sends multicast
+// SearchRequests, which is the only way to get a scan into its discovery window, so it is
+// skipped in short mode and on machines without a scannable interface.
+func TestDiscovererCloseCancelsRunningDiscovery(t *testing.T) {
+ if testing.Short() {
+ t.Skip("this test does real network i/o")
+ }
+ requireScannableInterface(t)
+
+ baseline := runtime.NumGoroutine()
+
+ d := testDiscoverer(t)
+ require.NoError(t, d.Discover(context.Background(), func(_ apiModel.PlcDiscoveryItem) {}))
+
+ start := time.Now()
+ requireCloseWithin(t, d, closeTimeout)
+ assert.Less(t, time.Since(start), discoveryWindow, "Close should cancel the running scans, not wait out the discovery window")
+
+ assertNoGoroutineLeak(t, baseline)
+}
+
+// TestDiscovererCloseWithoutDiscover pins that Close is safe (and quick) even if
+// no discovery ever ran.
+func TestDiscovererCloseWithoutDiscover(t *testing.T) {
+ baseline := runtime.NumGoroutine()
+ d := testDiscoverer(t)
+ requireCloseWithin(t, d, closeTimeout)
+ assertNoGoroutineLeak(t, baseline)
+}
+
+func buildTestSearchResponse(deviceName string, addr []byte, port uint16) driverModel.SearchResponse {
+ friendlyName := make([]byte, 30)
+ copy(friendlyName, deviceName)
+ return driverModel.NewSearchResponse(
+ driverModel.NewHPAIControlEndpoint(
+ driverModel.HostProtocolCode_IPV4_UDP,
+ driverModel.NewIPAddress(addr),
+ port,
+ ),
+ driverModel.NewDIBDeviceInfo(
+ 8,
+ driverModel.KnxMedium_MEDIUM_TP1,
+ driverModel.NewDeviceStatus(false),
+ driverModel.NewKnxAddress(1, 1, 0),
+ driverModel.NewProjectInstallationIdentifier(0, 1),
+ []byte{0, 0, 0, 0, 0, 0},
+ driverModel.NewIPAddress([]byte{224, 0, 23, 12}),
+ driverModel.NewMACAddress([]byte{0, 0, 0, 0, 0, 0}),
+ friendlyName,
+ ),
+ driverModel.NewDIBSuppSvcFamilies(2, nil),
+ )
+}
+
+// TestDiscovererDiscoveryItemFromMessage pins the (formerly unchecked) type
+// assertion on messages coming out of the codec: anything which isn't a
+// SearchResponse has to be skipped instead of panicking the scan goroutine.
+func TestDiscovererDiscoveryItemFromMessage(t *testing.T) {
+ tests := []struct {
+ name string
+ message spi.Message
+ wantOk bool
+ wantName string
+ wantRemoteHost string
+ }{
+ {
+ name: "nil message",
+ message: nil,
+ wantOk: false,
+ },
+ {
+ name: "not a search response",
+ message: driverModel.NewSearchRequest(
+ driverModel.NewHPAIDiscoveryEndpoint(
+ driverModel.HostProtocolCode_IPV4_UDP,
+ driverModel.NewIPAddress([]byte{192, 168, 42, 11}),
+ 3671,
+ ),
+ ),
+ wantOk: false,
+ },
+ {
+ name: "search response",
+ message: buildTestSearchResponse("KNX IP Router", []byte{192, 168, 42, 11}, 3671),
+ wantOk: true,
+ wantName: "KNX IP Router",
+ wantRemoteHost: "192.168.42.11:3671",
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ d := testDiscoverer(t)
+ t.Cleanup(func() {
+ require.NoError(t, d.Close())
+ })
+ got, ok := d.discoveryItemFromMessage(tt.message)
+ require.Equal(t, tt.wantOk, ok)
+ if !tt.wantOk {
+ assert.Nil(t, got)
+ return
+ }
+ require.NotNil(t, got)
+ assert.Equal(t, tt.wantName, got.GetName())
+ assert.Equal(t, "knxnet-ip", got.GetProtocolCode())
+ assert.Equal(t, "udp", got.GetTransportCode())
+ assert.Equal(t, tt.wantRemoteHost, got.GetTransportUrl().Host)
+ })
+ }
+}