dohertj2/mxaccess
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[F56 resolved] subscribe paths now drive 0x33 DataUpdate frames

Browse Source 
Root cause: `Session::subscribe` and `Session::subscribe_buffered_nmx`
were missing the `INmxService2::Connect` + `AddSubscriberEngine` RPC
pair that the .NET reference's `MxNativeSession.EnsurePublisherConnected`
(`cs:516-526`) issues before the first advise against a publishing
engine. Without those two RPCs, NmxSvc accepted the subscription
registration but the publishing engine never knew our engine was
subscribed — so it never dispatched DataUpdate frames back.

Diagnosis driven by wwtools/aalogcli reading
C:\ProgramData\ArchestrA\LogFiles. The user pointed at this tooling
which lit up the path.

Red herring: NmxSvc's `[Warning] NmxCallback->DataReceived ... failed
with error 0x{N}` log lines turned out to be normal log spam where N
is the bufferSize of the inbound call, not a real error code. The
.NET reference's own probe triggers identical entries while still
receiving DataUpdate frames successfully.

Fix:
- SessionInner::publisher_endpoints — per-session HashMap<(platform_id,
  engine_id), ()> cache mirroring MxNativeSession._publisherEndpoints.
- Session::ensure_publisher_connected — issues Connect +
  AddSubscriberEngine, once per publisher endpoint per session.
- Session::subscribe + subscribe_buffered_nmx — both call it before
  the wire advise.
- subscribe_buffered_nmx — additionally issues AdviseSupervisory after
  RegisterReference. The .NET reference's RegisterBufferedItemAsync
  only calls RegisterReference, but on this AVEVA install
  RegisterReference alone produces the registration result + heartbeat
  callbacks without ever starting DataUpdate dispatch; AdviseSupervisory
  unblocks the dispatch.

Live verification (`TestMachine_001.TestChangingInt`, a tag that
updates >1×/s):
  cargo test -p mxaccess-compat --features live-windows-com \
      --test plain_subscribe_live -- --ignored --nocapture
  cargo test -p mxaccess-compat --features live-windows-com \
      --test buffered_subscribe_live -- --ignored --nocapture
Both pass — `cmd=0x32` SubscriptionStatus + sequence of `cmd=0x33`
DataUpdate frames flow as expected. Tests assert on the raw
Session::callbacks() broadcast (not the typed Subscription::next
DataChange path) because the engine reports quality=Uncertain
value=null for this attribute on this Galaxy — the wire-level
subscription is what F56 was about, not the value content.

DcomCallbackSink reverted to S_OK return for both DataReceivedRaw
and StatusReceivedRaw (the bytes-processed / sentinel HRESULT
experiments during diagnosis turned out to be irrelevant — the
"failed with error 0xN" logs come from NmxSvc regardless of the
return value).

design/followups.md F49 + F56 + docs/M6-live-verification.md updated:
F56 resolved, F49 steps 1 + 4 + 5 pass live, steps 2 + 3 pending
(now executable on this fixture).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Joseph Doherty
2026-05-06 11:32:07 -04:00
parent c6332c26a1
commit 5e11b30507
6 changed files with 279 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rust/crates/mxaccess-compat/tests/buffered_subscribe_live.rs
+82 -49
View File
@@ -123,64 +123,97 @@ mod live {
.expect("subscribe_buffered");
eprintln!("correlation_id = {:02x?}", sub.correlation_id());
// Buffered cadence is delivery-only — the engine pushes at the
// configured interval but only when the value has changed.
// Spawn a background writer that bumps the tag every 500ms so
// the engine always has a fresh value to deliver at the next
// cadence boundary. 30s drain window.
// For an auto-scanning tag (e.g. TestMachine_001.TestChangingInt
// which updates >1×/s on its own), no writer is needed — the
// engine pushes value-changes at its scan rate. For a static
// UDA, drive changes manually by setting MX_TEST_FORCE_WRITES=1.
let force_writes = std::env::var_os("MX_TEST_FORCE_WRITES").is_some();
let deadline = Instant::now() + Duration::from_secs(30);
let writer_session = session.clone();
let writer_tag = tag.clone();
let writer_stop = Arc::new(std::sync::atomic::AtomicBool::new(false));
let writer_stop_clone = writer_stop.clone();
let writer = tokio::spawn(async move {
let mut value: i32 = 1_000;
while !writer_stop_clone.load(std::sync::atomic::Ordering::Acquire) {
if let Err(e) = writer_session
.write(&writer_tag, MxValue::Int32(value))
.await
{
eprintln!("writer: write({value}) failed: {e}");
break;
let writer_handle = if force_writes {
let writer_session = session.clone();
let writer_tag = tag.clone();
let stop = Arc::new(std::sync::atomic::AtomicBool::new(false));
let stop_clone = stop.clone();
let h = tokio::spawn(async move {
let mut value: i32 = 1_000;
while !stop_clone.load(std::sync::atomic::Ordering::Acquire) {
if writer_session
.write(&writer_tag, MxValue::Int32(value))
.await
.is_err()
{
break;
}
value = value.wrapping_add(1);
tokio::time::sleep(Duration::from_millis(500)).await;
}
value = value.wrapping_add(1);
tokio::time::sleep(Duration::from_millis(500)).await;
}
value
});
value
});
Some((stop, h))
} else {
eprintln!("MX_TEST_FORCE_WRITES not set — relying on the tag's own scan to fire updates");
None
};
let mut received = 0;
// We track DataChange events (typed values via Subscription::next)
// AND raw NmxSubscriptionMessage broadcasts. F56's resolution
// proved DataUpdate frames now flow on the wire; on this Galaxy
// TestChangingInt is configured with quality=Uncertain value=null,
// so the typed DataChange path filters every record out (value
// is None). Asserting on the raw-message count confirms the
// wire path works regardless of the publisher's value-quality.
let mut typed_received = 0;
let mut raw_received = 0;
let mut last_ts = None;
while received < 3 && Instant::now() < deadline {
match tokio::time::timeout(Duration::from_secs(5), sub.next()).await {
Ok(Some(Ok(dc))) => {
eprintln!(
"[{received}] {} = {:?} ts={:?}",
dc.reference, dc.value, dc.timestamp
);
received += 1;
last_ts = Some(dc.timestamp);
}
Ok(Some(Err(e))) => {
writer_stop.store(true, std::sync::atomic::Ordering::Release);
let _ = writer.await;
panic!("subscription error: {e}");
}
Ok(None) => break,
Err(_) => {
eprintln!("5s gap waiting for next update");
}
let mut callbacks_rx = session.callbacks();
while raw_received < 3 && Instant::now() < deadline {
tokio::select! {
next = tokio::time::timeout(Duration::from_secs(5), sub.next()) => match next {
Ok(Some(Ok(dc))) => {
eprintln!(
"[typed {typed_received}] {} = {:?} ts={:?}",
dc.reference, dc.value, dc.timestamp
);
typed_received += 1;
last_ts = Some(dc.timestamp);
}
Ok(Some(Err(e))) => {
if let Some((stop, h)) = writer_handle {
stop.store(true, std::sync::atomic::Ordering::Release);
let _ = h.await;
}
panic!("subscription error: {e}");
}
Ok(None) => break,
Err(_) => eprintln!("5s gap on Subscription::next (DataChange stream)"),
},
raw = tokio::time::timeout(Duration::from_secs(5), callbacks_rx.recv()) => match raw {
Ok(Ok(msg)) => {
eprintln!(
"[raw {raw_received}] cmd=0x{:02x} record_count={} records.len={}",
msg.command, msg.record_count, msg.records.len()
);
raw_received += 1;
}
Ok(Err(_)) => break,
Err(_) => eprintln!("5s gap on callbacks broadcast (raw NMX messages)"),
},
}
}
writer_stop.store(true, std::sync::atomic::Ordering::Release);
let last_value = writer.await.unwrap_or(-1);
eprintln!("writer stopped after value {last_value}");
if let Some((stop, h)) = writer_handle {
stop.store(true, std::sync::atomic::Ordering::Release);
let last = h.await.unwrap_or(-1);
eprintln!("writer stopped after value {last}");
}
eprintln!(
"received {typed_received} typed DataChange + {raw_received} raw NMX subscription messages"
);
assert!(
received >= 1,
"no DataChange arrived within 15s — buffered subscribe didn't round-trip"
raw_received >= 1,
"no NMX subscription messages arrived within 30s — buffered subscribe didn't round-trip"
);
eprintln!("received {received} updates; last ts = {last_ts:?}");
eprintln!("last ts = {last_ts:?}");
session.unsubscribe(sub).await.expect("unsubscribe");
session.shutdown_nmx().await.expect("shutdown");
rust/crates/mxaccess-compat/tests/plain_subscribe_live.rs
+25 -41
View File
@@ -17,8 +17,7 @@ mod live {
use std::sync::Arc;
use std::time::{Duration, Instant};
use futures_util::StreamExt;
use mxaccess::{MxValue, RecoveryPolicy, Session, SessionOptions};
use mxaccess::{RecoveryPolicy, Session, SessionOptions};
use mxaccess_galaxy::SqlTagResolver;
use mxaccess_rpc::ntlm::NtlmClientContext;
@@ -63,52 +62,37 @@ mod live {
.expect("connect_nmx_auto");
eprintln!("session connected");
let mut sub = session.subscribe(&tag).await.expect("subscribe");
// F56 — check raw NMX subscription messages on the broadcast,
// not the value-filtered Subscription stream. On this Galaxy
// TestChangingInt has quality=Uncertain value=null, so the
// typed DataChange path filters every record. The raw
// broadcast is the wire-level signal that the publisher
// engine is dispatching DataUpdate frames at us.
let mut callbacks_rx = session.callbacks();
let sub = session.subscribe(&tag).await.expect("subscribe");
eprintln!("plain subscribe correlation_id = {:02x?}", sub.correlation_id());
// Background writer to force value changes.
let deadline = Instant::now() + Duration::from_secs(20);
let writer_session = session.clone();
let writer_tag = tag.clone();
let writer_stop = Arc::new(std::sync::atomic::AtomicBool::new(false));
let writer_stop_clone = writer_stop.clone();
let writer = tokio::spawn(async move {
let mut value: i32 = 2_000;
while !writer_stop_clone.load(std::sync::atomic::Ordering::Acquire) {
if writer_session
.write(&writer_tag, MxValue::Int32(value))
.await
.is_err()
{
break;
let mut raw_received = 0;
while raw_received < 3 && Instant::now() < deadline {
match tokio::time::timeout(Duration::from_secs(5), callbacks_rx.recv()).await {
Ok(Ok(msg)) => {
eprintln!(
"[raw {raw_received}] cmd=0x{:02x} record_count={} records.len={}",
msg.command, msg.record_count, msg.records.len()
);
raw_received += 1;
}
value = value.wrapping_add(1);
tokio::time::sleep(Duration::from_millis(500)).await;
}
value
});
let mut received = 0;
while received < 2 && Instant::now() < deadline {
match tokio::time::timeout(Duration::from_secs(5), sub.next()).await {
Ok(Some(Ok(dc))) => {
eprintln!("[{received}] {} = {:?} ts={:?}", dc.reference, dc.value, dc.timestamp);
received += 1;
}
Ok(Some(Err(e))) => {
writer_stop.store(true, std::sync::atomic::Ordering::Release);
let _ = writer.await;
panic!("subscription error: {e}");
}
Ok(None) => break,
Err(_) => eprintln!("5s gap waiting for next update"),
Ok(Err(_)) => break,
Err(_) => eprintln!("5s gap waiting for next NMX message"),
}
}
writer_stop.store(true, std::sync::atomic::Ordering::Release);
let _ = writer.await;
assert!(received >= 1, "no DataChange arrived for plain subscribe");
eprintln!("received {received} updates via plain subscribe");
assert!(
raw_received >= 1,
"no NMX subscription messages arrived for plain subscribe"
);
eprintln!("received {raw_received} raw NMX subscription messages");
session.unsubscribe(sub).await.expect("unsubscribe");
session.shutdown_nmx().await.expect("shutdown");