feat(otopcua): DriverInstanceActor.TriggerRediscovery message (follow-up C)

src/Server/ZB.MOM.WW.OtOpcUa.Runtime/Drivers/DriverInstanceActor.cs

@@ -113,6 +113,16 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
     /// the parent dedups and injection is idempotent.</summary>
     public sealed record DiscoveredNodesReady(string DriverInstanceId, IReadOnlyList<DiscoveredNode> Nodes);
 
+    /// <summary>
+    ///     Sent by <see cref="DriverHostActor"/> to ask this driver child to re-run post-connect discovery
+    ///     after the host rebinds the driver to a new equipment. Handled only in <c>Connected</c>, where it
+    ///     re-kicks <see cref="StartDiscovery"/> — which already honours the driver's
+    ///     <see cref="ITagDiscovery.RediscoverPolicy"/> and the <see cref="ITagDiscovery"/> guard, tagging the
+    ///     fresh pass with the current init generation. In any non-Connected state it is a deliberate no-op:
+    ///     the driver's eventual (re)connect re-discovers anyway, so there is nothing to do and nothing to log.
+    /// </summary>
+    public sealed record TriggerRediscovery;
+
     /// <summary>Internal self-tick driving bounded post-connect re-discovery (FixedTree populates ~0–2s after connect).
     /// <paramref name="PreviousSignature"/> is the ordered-distinct full-reference signature of the prior pass's
     /// captured set (empty string on the first tick); re-discovery stops once a non-empty set repeats it.</summary>
@@ -312,6 +322,8 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
         // Stubbed drivers never enter Connected, so they never kick discovery; swallow defensively in case a
         // re-discovery self-tick is ever routed here so it doesn't surface as an Akka Unhandled message.
         Receive<RediscoverTick>(_ => { });
+        // A TriggerRediscovery is meaningless to a stubbed (never-Connected) driver — silently ignore it.
+        Receive<TriggerRediscovery>(_ => { });
         Receive<HealthPollTick>(_ => PublishHealthSnapshot());
     }
 
@@ -368,6 +380,9 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
         // Likewise the attempt-0 re-discovery self-tick (sent on Connected entry) can be overtaken by an
         // already-queued disconnect; swallow it — the next Connected entry re-kicks discovery.
         Receive<RediscoverTick>(_ => { });
+        // A TriggerRediscovery arriving while not Connected is a deliberate no-op — the (re)connect path
+        // re-runs discovery anyway. Swallow it so it stays a clean silent no-op (no Unhandled event).
+        Receive<TriggerRediscovery>(_ => { });
         Receive<HealthPollTick>(_ => PublishHealthSnapshot());
     }
 
@@ -393,6 +408,10 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
             PublishHealthSnapshot();
         });
         ReceiveAsync<RediscoverTick>(HandleRediscoverAsync);
+        // The host asks for a fresh discovery pass after rebinding the driver to a new equipment. Re-kick the
+        // bounded loop via StartDiscovery (honours RediscoverPolicy + the ITagDiscovery guard, tagged with the
+        // current _initGeneration). Only handled here in Connected — non-Connected states no-op it below.
+        Receive<TriggerRediscovery>(_ => StartDiscovery());
         ReceiveAsync<WriteAttribute>(HandleWriteAsync);
         ReceiveAsync<RouteAlarmAck>(HandleAcknowledgeAsync);
         ReceiveAsync<Subscribe>(HandleSubscribeAsync);
@@ -476,6 +495,9 @@ public sealed class DriverInstanceActor : ReceiveActor, IWithTimers
         // Likewise the attempt-0 re-discovery self-tick (sent on Connected entry) can be overtaken by an
         // already-queued disconnect; swallow it — the next Connected entry re-kicks discovery.
         Receive<RediscoverTick>(_ => { });
+        // A TriggerRediscovery arriving while not Connected is a deliberate no-op — the (re)connect path
+        // re-runs discovery anyway. Swallow it so it stays a clean silent no-op (no Unhandled event).
+        Receive<TriggerRediscovery>(_ => { });
         Receive<HealthPollTick>(_ => PublishHealthSnapshot());
         Timers.StartPeriodicTimer("retry-connect", RetryConnect.Instance, _reconnectInterval);
     }