Stream live MXAccess advice events from the Rust worker

This commit is contained in:
Joseph Doherty
2026-11-21 08:56:01 -05:00
parent 1a44b5ac31
commit 00a597b08b
9 changed files with 1560 additions and 46 deletions
@@ -1,9 +1,15 @@
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Net;
using System.Text;
using Google.Protobuf.WellKnownTypes;
using Grpc.Core;
using Grpc.Net.Client;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Server.Kestrel.Core;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using ZB.MOM.WW.MxGateway.Contracts;
@@ -17,6 +23,7 @@ using ZB.MOM.WW.MxGateway.Server.Sessions;
using ZB.MOM.WW.MxGateway.Server.Workers;
using ZB.MOM.WW.MxGateway.IntegrationTests.TestSupport;
using Xunit.Abstractions;
using SessionOptions = ZB.MOM.WW.MxGateway.Server.Configuration.SessionOptions;
namespace ZB.MOM.WW.MxGateway.IntegrationTests;
@@ -115,6 +122,163 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output)
}
}
/// <summary>Verifies Rust worker callbacks over the gateway's live HTTP/2 gRPC endpoint.</summary>
/// <returns>A task that represents the live test.</returns>
[RustWorkerLiveFact]
public async Task GatewayGrpc_WithRustWorker_StreamsChangingIntegersAndUnadvises()
{
const string itemDefinition = "TestMachine_001.TestChangingInt";
string workerPath = IntegrationTestEnvironment.ResolveLiveMxAccessWorkerExecutablePath();
TestWorkerProcessFactory processFactory = new(output);
await using GatewayServiceFixture fixture = new(workerPath, processFactory, output);
WebApplicationBuilder builder = WebApplication.CreateSlimBuilder();
builder.WebHost.ConfigureKestrel(options =>
options.Listen(IPAddress.Loopback, 0, listener => listener.Protocols = HttpProtocols.Http2));
builder.Services.AddGrpc();
builder.Services.AddSingleton(fixture.Service);
await using WebApplication app = builder.Build();
app.MapGrpcService<MxAccessGatewayService>();
using CancellationTokenSource deadline = new(TimeSpan.FromSeconds(90));
CancellationToken token = deadline.Token;
await app.StartAsync(token).ConfigureAwait(false);
using GrpcChannel channel = GrpcChannel.ForAddress(app.Urls.Single());
MxAccessGateway.MxAccessGatewayClient client = new(channel);
OpenSessionReply opened = await client.OpenSessionAsync(
new OpenSessionRequest { ClientSessionName = "rust-worker-live-events" },
cancellationToken: token).ResponseAsync.ConfigureAwait(false);
Assert.Equal(ProtocolStatusCode.Ok, opened.ProtocolStatus.Code);
string sessionId = opened.SessionId;
try
{
async Task<MxCommandReply> InvokeAsync(MxCommandRequest request)
{
MxCommandReply reply = await client.InvokeAsync(request, cancellationToken: token)
.ResponseAsync.ConfigureAwait(false);
Assert.True(reply.ProtocolStatus.Code == ProtocolStatusCode.Ok, reply.ToString());
return reply;
}
MxCommandReply worker = await InvokeAsync(new MxCommandRequest
{
SessionId = sessionId,
ClientCorrelationId = "rust-worker-info",
Command = new MxCommand { Kind = MxCommandKind.GetWorkerInfo, GetWorkerInfo = new GetWorkerInfoCommand() },
}).ConfigureAwait(false);
Assert.EndsWith("-rust", worker.WorkerInfo.WorkerVersion, StringComparison.Ordinal);
Assert.Equal(opened.WorkerProcessId, worker.WorkerInfo.WorkerProcessId);
MxCommandReply registration = await InvokeAsync(CreateRegisterRequest(sessionId)).ConfigureAwait(false);
int serverHandle = registration.Register.ServerHandle;
MxCommandRequest addItem = CreateAddItemRequest(sessionId, serverHandle);
addItem.Command.AddItem.ItemDefinition = itemDefinition;
MxCommandReply added = await InvokeAsync(addItem).ConfigureAwait(false);
int itemHandle = added.AddItem.ItemHandle;
using (AsyncServerStreamingCall<MxEvent> stream = client.StreamEvents(
new StreamEventsRequest { SessionId = sessionId, EmitStreamAttached = true },
cancellationToken: token))
{
Assert.True(await stream.ResponseStream.MoveNext(token).ConfigureAwait(false));
Assert.NotNull(stream.ResponseStream.Current.StreamAttached);
await InvokeAsync(CreateAdviseRequest(sessionId, serverHandle, itemHandle)).ConfigureAwait(false);
MxEvent? first = null;
bool observedChange = false;
ulong lastSequence = 0;
while (await stream.ResponseStream.MoveNext(token).ConfigureAwait(false))
{
MxEvent change = stream.ResponseStream.Current;
Assert.True(change.WorkerSequence > lastSequence);
lastSequence = change.WorkerSequence;
if (change.Family != MxEventFamily.OnDataChange ||
change.Value?.KindCase != MxValue.KindOneofCase.Int32Value ||
(change.Quality & 0xc0) != 0xc0)
{
continue;
}
Assert.Equal(sessionId, change.SessionId);
Assert.Equal(serverHandle, change.ServerHandle);
Assert.Equal(itemHandle, change.ItemHandle);
Assert.NotNull(change.SourceTimestamp);
Assert.NotNull(change.WorkerTimestamp);
Assert.Contains(change.Statuses, status => status.Category == MxStatusCategory.Ok);
if (first is not null && change.Value.Int32Value != first.Value.Int32Value)
{
output.WriteLine(
$"{itemDefinition} delivered through gateway: {first.Value.Int32Value} -> {change.Value.Int32Value}, " +
$"worker sequences {first.WorkerSequence} -> {change.WorkerSequence}, quality {change.Quality}.");
observedChange = true;
break;
}
first ??= change;
}
Assert.True(observedChange, "The gateway did not deliver distinct TestChangingInt values.");
await InvokeAsync(new MxCommandRequest
{
SessionId = sessionId,
ClientCorrelationId = "rust-unadvise",
Command = new MxCommand
{
Kind = MxCommandKind.UnAdvise,
UnAdvise = new UnAdviseCommand { ServerHandle = serverHandle, ItemHandle = itemHandle },
},
}).ConfigureAwait(false);
// A callback queued before UnAdvise may still cross the pipe.
// Observe the same stream and reject updates generated after acknowledgement.
DateTime unadvisedAt = DateTime.UtcNow;
using CancellationTokenSource quiet = CancellationTokenSource.CreateLinkedTokenSource(token);
quiet.CancelAfter(TimeSpan.FromSeconds(2));
try
{
while (await stream.ResponseStream.MoveNext(quiet.Token).ConfigureAwait(false))
{
MxEvent change = stream.ResponseStream.Current;
Assert.False(change.Family == MxEventFamily.OnDataChange &&
change.ServerHandle == serverHandle && change.ItemHandle == itemHandle &&
change.WorkerTimestamp.ToDateTime() >= unadvisedAt,
"The worker sent a new data change after UnAdvise completed.");
}
Assert.Fail("The event stream ended before the quiet period elapsed.");
}
catch (RpcException exception) when (exception.StatusCode == StatusCode.Cancelled && quiet.IsCancellationRequested)
{
Assert.False(token.IsCancellationRequested);
}
catch (OperationCanceledException) when (quiet.IsCancellationRequested)
{
Assert.False(token.IsCancellationRequested);
}
}
}
finally
{
CloseSessionReply closed = await client.CloseSessionAsync(
new CloseSessionRequest { SessionId = sessionId },
deadline: DateTime.UtcNow.AddSeconds(25)).ResponseAsync.ConfigureAwait(false);
Assert.Equal(ProtocolStatusCode.Ok, closed.ProtocolStatus.Code);
}
}
private sealed class RustWorkerLiveFactAttribute : FactAttribute
{
public RustWorkerLiveFactAttribute()
{
const string optIn = "MXGATEWAY_RUN_RUST_WORKER_LIVE_TESTS";
if (!IntegrationTestEnvironment.IsEnabled(optIn))
{
Skip = $"Set {optIn}=1 to run the Rust worker live test.";
}
}
}
/// <summary>
/// Verifies that a Write command round-trips through live MXAccess against an advised item
/// and that the worker emits a matching <see cref="MxEventFamily.OnWriteComplete"/> event
+4
View File
@@ -13,9 +13,13 @@ tokio = { version = "1.48", features = ["io-util"] }
tokio = { version = "1.48", features = ["macros", "net", "rt", "sync", "time"] }
windows-sys = { version = "0.61", features = [
"Win32_Foundation",
"Win32_Globalization",
"Win32_Security",
"Win32_System_Com",
"Win32_System_Ole",
"Win32_System_Threading",
"Win32_System_Time",
"Win32_System_Variant",
"Win32_UI_WindowsAndMessaging",
] }
+34 -9
View File
@@ -6,15 +6,21 @@ schemas at build time.
The worker authenticates the launch nonce, negotiates a frame limit, activates
LMXProxy on a dedicated message-pumping STA, and reports readiness and heartbeats.
It supports Register, Unregister, AddItem, RemoveItem, and the worker diagnostic
commands. Shutdown unregisters any remaining clients before releasing COM. The
existing C# worker is the gateway default.
It supports Register, Unregister, AddItem, RemoveItem, Advise, UnAdvise, and the
worker diagnostic commands. The worker uses the base MXAccess COM connection
point for OnDataChange, OperationComplete, and OnWriteComplete notifications.
OnDataChange carries the value, quality, MXAccess status records, source
timestamp when available, and worker sequence and timestamp. The bounded queue
faults the session on overflow. Shutdown detaches the sink, unadvises remaining
items, and unregisters clients before releasing COM. The C# worker is the
gateway default.
COM connection points, event delivery, Advise, value and status conversion beyond
integer handles, writes, bulk commands, alarms, and record-info pinning remain to
be implemented. Unsupported commands return `InvalidRequest`. The prototype
serializes commands and does not interrupt COM calls on cancellation. If a call
exceeds the STA timeout, the worker faults the session and exits.
Event conversion supports standard Automation scalar values and homogeneous
arrays of those types. Other variant types are reported as unknown with the
Automation type in the diagnostic. Writes, buffered or supervisory advice,
bulk commands, and alarms remain to be implemented. Unsupported commands
return `InvalidRequest`. The worker serializes commands. If a COM call exceeds
the STA timeout, the worker faults the session and exits.
## Build and test
@@ -41,15 +47,34 @@ handshake, heartbeat, registration, item lifecycle when configured, and graceful
shutdown. It runs without a gateway service. Portable framing tests also run
with `cargo test --locked` on macOS and Linux.
From the repository root on a Windows development host with
`TestMachine_001.TestChangingInt` deployed, run the opt-in HTTP/2 test to verify
the Rust worker through the gateway:
```powershell
$env:MXGATEWAY_RUN_RUST_WORKER_LIVE_TESTS = '1'
$env:MXGATEWAY_LIVE_MXACCESS_WORKER_EXE = (Resolve-Path 'src/mxgateway-worker-rust/target/i686-pc-windows-msvc/release/mxgateway-worker-rust.exe').Path
dotnet test src/ZB.MOM.WW.MxGateway.IntegrationTests --filter FullyQualifiedName~GatewayGrpc_WithRustWorker_StreamsChangingIntegersAndUnadvises
```
The test starts the gateway gRPC service on an ephemeral loopback port and
launches the configured Rust worker. It verifies that the client receives
distinct good-quality integer values in sequence and that the worker emits no
new data for the item after UnAdvise.
## COM interface evidence
The native adapter uses the dual `ILMXProxyServer` interface from the installed
`ArchestrA.MxAccess` 3.2.0.0 assembly. REA inspection confirmed the declaration
order and managed signatures for Register, Unregister, AddItem, and RemoveItem.
Windows reflection confirmed the interface IID, dual-interface flag, DISPIDs, and
BSTR input annotations. The live test exercises the corresponding native calls.
BSTR input annotations. REA and Windows reflection also identified the base
event dispatch interface and the `MXSTATUS_PROXY` layout. The live tests exercise
the corresponding native calls and event callbacks.
- Assembly SHA-256
`cba8b607305ee0c70ca38b09eca645ae3b98c35a7b78ec051eb4381f48d9e0b1`
- REA managed member evidence
`ev_78053da509335e3e3749b8e6bb020f28c45255b54d910546659c6760eb52160b`
- REA event member evidence
`ev_97162abcd831b2d84b5b43fb72cd9876252bbe3bb0af5c4673a6954911500e54`
+563
View File
@@ -0,0 +1,563 @@
use std::ffi::c_void;
use std::mem::{align_of, size_of};
use std::ptr::{null, null_mut};
use std::slice;
use prost_types::Timestamp;
use windows_sys::core::BSTR;
use windows_sys::Win32::Foundation::{SysStringLen, FILETIME, SYSTEMTIME};
use windows_sys::Win32::Globalization::GetUserDefaultLCID;
use windows_sys::Win32::System::Com::SAFEARRAY;
use windows_sys::Win32::System::Ole::{
SafeArrayAccessData, SafeArrayGetDim, SafeArrayGetElemsize, SafeArrayGetLBound,
SafeArrayGetUBound, SafeArrayGetVartype, SafeArrayPtrOfIndex, SafeArrayUnaccessData,
VarDateFromStr,
};
use windows_sys::Win32::System::Time::{SystemTimeToFileTime, TzSpecificLocalTimeToSystemTime};
use windows_sys::Win32::System::Variant::*;
use crate::wire::mxaccess_gateway::v1::{
mx_array::Values, mx_value::Kind, BoolArray, DoubleArray, FloatArray, Int32Array, Int64Array,
MxArray, MxDataType, MxStatusCategory, MxStatusProxy, MxStatusSource, MxValue, StringArray,
TimestampArray,
};
pub fn int32(value: i32) -> MxValue {
value_of(MxDataType::Integer, "VT_I4", Kind::Int32Value(value))
}
// A dispatch argument can wrap the actual VARIANT in VT_VARIANT|VT_BYREF.
pub unsafe fn unwrap_variant(mut value: VARIANT) -> Option<VARIANT> {
for _ in 0..8 {
let inner = unsafe { &value.Anonymous.Anonymous };
if inner.vt != (VT_VARIANT | VT_BYREF) {
return Some(value);
}
let by_ref = unsafe { inner.Anonymous.pvarVal };
if by_ref.is_null() {
return None;
}
value = unsafe { by_ref.read_unaligned() };
}
None
}
pub unsafe fn dispatch_i32(value: &VARIANT) -> Option<i32> {
let inner = unsafe { &unwrap_variant(*value)?.Anonymous.Anonymous };
match inner.vt {
VT_I4 | VT_INT => Some(unsafe { inner.Anonymous.lVal }),
VT_I2 => Some(unsafe { inner.Anonymous.iVal.into() }),
_ => None,
}
}
pub unsafe fn dispatch_value(value: &VARIANT) -> MxValue {
let Some(value) = (unsafe { unwrap_variant(*value) }) else {
return unknown("VT_VARIANT|VT_BYREF".into());
};
let inner = unsafe { &value.Anonymous.Anonymous };
if inner.vt & VT_ARRAY != 0 {
let array = unsafe { variant_array(&value) };
return unsafe { dispatch_array(array, inner.vt & !(VT_ARRAY | VT_BYREF)) }.unwrap_or_else(
|| {
unknown(format!(
"SAFEARRAY(VT_0x{:04X})",
inner.vt & !(VT_ARRAY | VT_BYREF)
))
},
);
}
let data = &inner.Anonymous;
// SAFETY: each field read is selected by the type tag of a live VARIANT.
unsafe {
match inner.vt {
VT_EMPTY | VT_NULL => MxValue {
data_type: MxDataType::NoData as i32,
variant_type: if inner.vt == VT_EMPTY {
"VT_EMPTY"
} else {
"VT_NULL"
}
.into(),
is_null: true,
..Default::default()
},
VT_I1 => value_of(
MxDataType::Integer,
"VT_I1",
Kind::Int32Value(data.cVal.into()),
),
VT_UI1 => value_of(
MxDataType::Integer,
"VT_UI1",
Kind::Int32Value(data.bVal.into()),
),
VT_I2 => value_of(
MxDataType::Integer,
"VT_I2",
Kind::Int32Value(data.iVal.into()),
),
VT_UI2 => value_of(
MxDataType::Integer,
"VT_UI2",
Kind::Int32Value(data.uiVal.into()),
),
VT_I4 | VT_INT => int32(data.lVal),
VT_UI4 | VT_UINT => value_of(
MxDataType::Integer,
"VT_UI4",
Kind::Int64Value(data.ulVal.into()),
),
VT_I8 => value_of(MxDataType::Integer, "VT_I8", Kind::Int64Value(data.llVal)),
VT_UI8 => i64::try_from(data.ullVal).map_or_else(
|_| unknown("VT_UI8".into()),
|value| value_of(MxDataType::Integer, "VT_UI8", Kind::Int64Value(value)),
),
VT_BOOL => value_of(
MxDataType::Boolean,
"VT_BOOL",
Kind::BoolValue(data.boolVal != 0),
),
VT_R4 => value_of(MxDataType::Float, "VT_R4", Kind::FloatValue(data.fltVal)),
VT_R8 => value_of(MxDataType::Double, "VT_R8", Kind::DoubleValue(data.dblVal)),
VT_BSTR => value_of(
MxDataType::String,
"VT_BSTR",
Kind::StringValue(bstr(data.bstrVal)),
),
VT_DATE => utc_ole_date(data.date).map_or_else(
|| unknown("VT_DATE".into()),
|value| value_of(MxDataType::Time, "VT_DATE", Kind::TimestampValue(value)),
),
vt => unknown(format!("VT_0x{vt:04X}")),
}
}
}
unsafe fn variant_array(value: &VARIANT) -> *mut SAFEARRAY {
let inner = unsafe { &value.Anonymous.Anonymous };
if inner.vt & VT_BYREF == 0 {
return unsafe { inner.Anonymous.parray };
}
let by_ref = unsafe { inner.Anonymous.pparray };
if by_ref.is_null() {
null_mut()
} else {
unsafe { by_ref.read_unaligned() }
}
}
unsafe fn dispatch_array(array: *mut SAFEARRAY, tag: u16) -> Option<MxValue> {
if array.is_null() {
return None;
}
let mut element_type = 0;
if unsafe { SafeArrayGetVartype(array, &mut element_type) } < 0 {
element_type = tag;
}
let array = unsafe { ArrayElements::new(array) }?;
macro_rules! read_array {
($native:ty, $type:ident, $variant:literal, $values:ident, $message:ident, $convert:expr) => {
(
MxDataType::$type,
$variant,
Values::$values($message {
values: unsafe { array.copy::<$native, _>($convert) }?,
}),
)
};
}
let (data_type, variant, values) = match element_type {
VT_I1 => read_array!(i8, Integer, "VT_I1", Int32Values, Int32Array, |v| Some(
i32::from(v)
)),
VT_UI1 => read_array!(u8, Integer, "VT_UI1", Int32Values, Int32Array, |v| Some(
i32::from(v)
)),
VT_I2 => read_array!(i16, Integer, "VT_I2", Int32Values, Int32Array, |v| Some(
i32::from(v)
)),
VT_UI2 => read_array!(u16, Integer, "VT_UI2", Int32Values, Int32Array, |v| Some(
i32::from(v)
)),
VT_I4 | VT_INT => read_array!(i32, Integer, "VT_I4", Int32Values, Int32Array, Some),
VT_UI4 | VT_UINT => read_array!(u32, Integer, "VT_UI4", Int64Values, Int64Array, |v| Some(
i64::from(v)
)),
VT_I8 => read_array!(i64, Integer, "VT_I8", Int64Values, Int64Array, Some),
VT_UI8 => read_array!(u64, Integer, "VT_UI8", Int64Values, Int64Array, |v| {
i64::try_from(v).ok()
}),
VT_BOOL => read_array!(i16, Boolean, "VT_BOOL", BoolValues, BoolArray, |v| Some(
v != 0
)),
VT_R4 => read_array!(f32, Float, "VT_R4", FloatValues, FloatArray, Some),
VT_R8 => read_array!(f64, Double, "VT_R8", DoubleValues, DoubleArray, Some),
VT_BSTR => read_array!(
BSTR,
String,
"VT_BSTR",
StringValues,
StringArray,
|v| Some(bstr(v))
),
VT_DATE => read_array!(f64, Time, "VT_DATE", TimestampValues, TimestampArray, |v| {
utc_ole_date(v)
}),
_ => return None,
};
let variant_type = format!("SAFEARRAY({variant})");
let data = MxArray {
element_data_type: data_type as i32,
variant_type: variant_type.clone(),
dimensions: array.dimensions(),
values: Some(values),
..Default::default()
};
Some(MxValue {
variant_type,
kind: Some(Kind::ArrayValue(data)),
..Default::default()
})
}
struct ArrayElements {
array: *mut SAFEARRAY,
bounds: Vec<(i32, i32)>,
}
impl ArrayElements {
unsafe fn new(array: *mut SAFEARRAY) -> Option<Self> {
let dimensions = unsafe { SafeArrayGetDim(array) };
if dimensions == 0 {
return None;
}
let mut bounds = Vec::with_capacity(dimensions as usize);
// SafeArrayPtrOfIndex expects the rightmost dimension first.
for dimension in 1..=dimensions {
let mut lower = 0;
let mut upper = 0;
if unsafe { SafeArrayGetLBound(array, dimension, &mut lower) } < 0
|| unsafe { SafeArrayGetUBound(array, dimension, &mut upper) } < 0
{
return None;
}
bounds.push((lower, upper));
}
let mut data = null_mut();
if unsafe { SafeArrayAccessData(array, &mut data) } < 0 {
return None;
}
Some(Self { array, bounds })
}
fn dimensions(&self) -> Vec<u32> {
self.bounds
.iter()
.rev()
.map(|&(lower, upper)| (i64::from(upper) - i64::from(lower) + 1).max(0) as u32)
.collect()
}
// The caller selects a Rust representation matching the Automation VARTYPE.
unsafe fn copy<T: Copy, O>(&self, convert: impl Fn(T) -> Option<O>) -> Option<Vec<O>> {
if unsafe { SafeArrayGetElemsize(self.array) } as usize != size_of::<T>() {
return None;
}
let mut values = Vec::new();
if self.bounds.iter().any(|&(lower, upper)| upper < lower) {
return Some(values);
}
let mut indices: Vec<_> = self.bounds.iter().map(|&(lower, _)| lower).collect();
loop {
let mut element: *mut c_void = null_mut();
if unsafe { SafeArrayPtrOfIndex(self.array, indices.as_ptr(), &mut element) } < 0
|| element.is_null()
{
return None;
}
values.push(convert(unsafe { element.cast::<T>().read_unaligned() })?);
let Some(next) = indices
.iter()
.zip(&self.bounds)
.position(|(&index, &(_, upper))| index < upper)
else {
break;
};
indices[next] += 1;
for (index, &(lower, _)) in indices[..next].iter_mut().zip(&self.bounds) {
*index = lower;
}
}
Some(values)
}
}
impl Drop for ArrayElements {
fn drop(&mut self) {
// SAFETY: new acquired an Automation array data lock.
unsafe { SafeArrayUnaccessData(self.array) };
}
}
fn value_of(data_type: MxDataType, variant_type: &str, kind: Kind) -> MxValue {
MxValue {
data_type: data_type as i32,
variant_type: variant_type.into(),
kind: Some(kind),
..Default::default()
}
}
fn unknown(variant_type: String) -> MxValue {
MxValue {
data_type: MxDataType::Unknown as i32,
raw_diagnostic: format!("Unsupported Automation value type {variant_type}"),
variant_type,
..Default::default()
}
}
unsafe fn bstr(value: BSTR) -> String {
if value.is_null() {
return String::new();
}
let length = unsafe { SysStringLen(value) } as usize;
String::from_utf16_lossy(unsafe { slice::from_raw_parts(value, length) })
}
pub unsafe fn dispatch_timestamp(value: &VARIANT) -> Option<Timestamp> {
let inner = unsafe { &unwrap_variant(*value)?.Anonymous.Anonymous };
match inner.vt {
VT_DATE => utc_ole_date(unsafe { inner.Anonymous.date }),
VT_BSTR => parse_timestamp(&unsafe { bstr(inner.Anonymous.bstrVal) }),
VT_I8 => file_time_timestamp(unsafe { inner.Anonymous.llVal }),
VT_UI8 => i64::try_from(unsafe { inner.Anonymous.ullVal })
.ok()
.and_then(file_time_timestamp),
_ => None,
}
}
fn parse_timestamp(text: &str) -> Option<Timestamp> {
// MXAccess appends fractional seconds to the local Automation date text.
// Parse the whole seconds with the user's locale and restore the fraction.
let mut text = text.trim().to_owned();
let mut milliseconds = 0;
if let Some((colon, _)) = text.match_indices(':').nth(1) {
let seconds = text[colon + 1..]
.bytes()
.take_while(u8::is_ascii_digit)
.count();
let separator = colon + 1 + seconds;
if seconds > 0 && matches!(text.as_bytes().get(separator), Some(b'.' | b',')) {
let digits = text[separator + 1..]
.bytes()
.take_while(u8::is_ascii_digit)
.count();
if digits > 0 {
let count = digits.min(3);
milliseconds = text[separator + 1..separator + 1 + count]
.parse::<u16>()
.ok()?
* 10_u16.pow(3 - count as u32);
text.drain(separator..separator + 1 + digits);
}
}
}
let text: Vec<_> = text.encode_utf16().chain([0]).collect();
let mut date = 0.0;
let locale = unsafe { GetUserDefaultLCID() };
if unsafe { VarDateFromStr(text.as_ptr(), locale, 0, &mut date) } < 0
&& unsafe { VarDateFromStr(text.as_ptr(), 0x0409, 0, &mut date) } < 0
{
return None;
}
local_ole_date(date, milliseconds)
}
fn utc_ole_date(date: f64) -> Option<Timestamp> {
if !(-657_435.0 < date && date < 2_958_466.0) {
return None;
}
// Preserve the existing worker's UTC interpretation of an unspecified
// COM DATE. For negative OLE values the fraction is still time after midnight.
let millis = (date.trunc() as i64 - 25_569) * 86_400_000
+ (date.fract().abs() * 86_400_000.0).round() as i64;
Some(Timestamp {
seconds: millis.div_euclid(1_000),
nanos: (millis.rem_euclid(1_000) * 1_000_000) as i32,
})
}
fn local_ole_date(date: f64, milliseconds: u16) -> Option<Timestamp> {
let mut local = SYSTEMTIME::default();
let mut utc = SYSTEMTIME::default();
let mut file_time = FILETIME::default();
// SAFETY: all output pointers refer to initialized writable Win32 structures.
if unsafe { VariantTimeToSystemTime(date, &mut local) } == 0 {
return None;
}
local.wMilliseconds = milliseconds;
if unsafe { TzSpecificLocalTimeToSystemTime(null(), &local, &mut utc) } == 0
|| unsafe { SystemTimeToFileTime(&utc, &mut file_time) } == 0
{
return None;
}
let ticks = (i64::from(file_time.dwHighDateTime) << 32) | i64::from(file_time.dwLowDateTime);
file_time_timestamp(ticks)
}
fn file_time_timestamp(ticks: i64) -> Option<Timestamp> {
if !(0..=2_650_467_743_999_999_999).contains(&ticks) {
return None;
}
let unix_ticks = ticks - 116_444_736_000_000_000;
Some(Timestamp {
seconds: unix_ticks.div_euclid(10_000_000),
nanos: (unix_ticks.rem_euclid(10_000_000) * 100) as i32,
})
}
// Installed MXSTATUS_PROXY 3.2: 16 bytes with members at offsets 0, 4, 8, 12.
#[repr(C)]
struct StatusRecord {
success: i16,
category: i32,
source: i32,
detail: i16,
}
pub unsafe fn dispatch_statuses(value: &VARIANT) -> Result<Vec<MxStatusProxy>, &'static str> {
let value = unsafe { unwrap_variant(*value) }.ok_or("null status VARIANT")?;
let inner = unsafe { &value.Anonymous.Anonymous };
let array = match inner.vt {
VT_EMPTY | VT_NULL => return Ok(Vec::new()),
tag if tag & VT_ARRAY != 0 => unsafe { variant_array(&value) },
_ => return Err("status VARIANT is not a SAFEARRAY"),
};
if array.is_null() {
return Ok(Vec::new());
}
unsafe { read_status_records(array) }
}
unsafe fn read_status_records(array: *const SAFEARRAY) -> Result<Vec<MxStatusProxy>, &'static str> {
let mut element_type = 0;
if unsafe { SafeArrayGetDim(array) } != 1
|| unsafe { SafeArrayGetVartype(array, &mut element_type) } < 0
|| element_type != VT_RECORD
|| unsafe { SafeArrayGetElemsize(array) } as usize != size_of::<StatusRecord>()
{
return Err("unexpected MXSTATUS_PROXY array layout");
}
let count = unsafe { (*array).rgsabound[0].cElements } as usize;
if count == 0 {
return Ok(Vec::new());
}
let mut data: *mut c_void = null_mut();
if unsafe { SafeArrayAccessData(array, &mut data) } < 0 {
return Err("could not access MXSTATUS_PROXY array");
}
let result = if data.is_null()
|| !(data as usize).is_multiple_of(align_of::<StatusRecord>())
|| count > isize::MAX as usize / size_of::<StatusRecord>()
{
Err("invalid MXSTATUS_PROXY array data")
} else {
// SAFETY: the checked one-dimensional record array remains locked while copied.
let records = unsafe { slice::from_raw_parts(data.cast::<StatusRecord>(), count) };
Ok(records
.iter()
.map(|record| MxStatusProxy {
success: record.success.into(),
category: match record.category {
0..=8 => record.category + 2,
_ => MxStatusCategory::Unknown as i32,
},
detected_by: match record.source {
0..=5 => record.source + 2,
_ => MxStatusSource::Unknown as i32,
},
detail: record.detail.into(),
raw_category: record.category,
raw_detected_by: record.source,
..Default::default()
})
.collect())
};
unsafe { SafeArrayUnaccessData(array) };
result
}
#[cfg(test)]
mod tests {
use super::*;
use windows_sys::Win32::System::Com::SAFEARRAYBOUND;
use windows_sys::Win32::System::Ole::{SafeArrayCreate, SafeArrayDestroy, SafeArrayPutElement};
#[test]
fn preserves_utc_automation_dates_and_file_time_precision() {
let epoch = Timestamp {
seconds: 0,
nanos: 0,
};
assert_eq!(utc_ole_date(25_569.0), Some(epoch));
assert_eq!(utc_ole_date(25_569.5).unwrap().seconds, 43_200);
assert_eq!(
file_time_timestamp(116_444_736_000_000_123).unwrap().nanos,
12_300
);
assert_eq!(file_time_timestamp(-1), None);
}
#[test]
fn maps_multidimensional_automation_array_in_logical_order() {
struct TestArray(*mut SAFEARRAY);
impl Drop for TestArray {
fn drop(&mut self) {
unsafe { SafeArrayDestroy(self.0) };
}
}
let bounds = [
SAFEARRAYBOUND {
cElements: 3,
lLbound: -1,
},
SAFEARRAYBOUND {
cElements: 2,
lLbound: 10,
},
];
// SAFETY: the bounds match the number of dimensions passed to Automation.
let array = TestArray(unsafe { SafeArrayCreate(VT_I4, 2, bounds.as_ptr()) });
assert!(!array.0.is_null());
for row in 10_i32..=11 {
for column in -1_i32..=1 {
let value = row * 10 + column;
let indices = [column, row];
assert_eq!(
unsafe {
SafeArrayPutElement(
array.0,
indices.as_ptr(),
(&value as *const i32).cast(),
)
},
0,
"invalid test SAFEARRAY indices {indices:?}",
);
}
}
let result = unsafe { dispatch_array(array.0, VT_I4) }.unwrap();
let Some(Kind::ArrayValue(result)) = result.kind else {
panic!("expected an array value");
};
assert_eq!(result.dimensions, [2, 3]);
let Some(Values::Int32Values(values)) = result.values else {
panic!("expected 32-bit integer values");
};
assert_eq!(values.values, [99, 100, 101, 109, 110, 111]);
}
}
+4
View File
@@ -1,9 +1,13 @@
#[cfg(all(windows, not(target_arch = "x86")))]
compile_error!("The MXAccess COM server requires a 32-bit x86 Windows worker.");
#[cfg(all(windows, target_arch = "x86"))]
mod automation;
#[cfg(all(windows, target_arch = "x86"))]
mod mxaccess;
#[cfg(all(windows, target_arch = "x86"))]
mod mxevent;
#[cfg(all(windows, target_arch = "x86"))]
mod session;
#[cfg(any(windows, test))]
mod wire;
+69 -12
View File
@@ -1,3 +1,4 @@
use crate::mxevent::{Connection, Publisher, RecordInfoPin};
use std::collections::BTreeSet;
use std::ffi::c_void;
use std::io;
@@ -29,6 +30,8 @@ pub enum Command {
Unregister(i32),
AddItem(i32, String),
RemoveItem(i32, i32),
Advise(i32, i32),
UnAdvise(i32, i32),
}
pub enum CommandError {
@@ -55,7 +58,7 @@ pub struct Sta {
}
impl Sta {
pub async fn start() -> Result<Self, StartError> {
pub async fn start(publisher: Publisher) -> Result<(Self, String), StartError> {
// SAFETY: unnamed auto-reset event. Ownership transfers to OwnedHandle.
let event = unsafe { CreateEventW(null(), 0, 0, null()) };
if event.is_null() {
@@ -68,7 +71,7 @@ impl Sta {
let thread_wake = Arc::clone(&wake);
thread::Builder::new()
.name("mxgateway-sta".into())
.spawn(move || run(requests, thread_wake, ready, finished))
.spawn(move || run(requests, thread_wake, ready, finished, publisher))
.map_err(StartError::Io)?;
let sta = Self {
@@ -76,11 +79,11 @@ impl Sta {
wake,
stopped: Some(stopped),
};
startup
let pin_status = startup
.await
.map_err(|_| StartError::Io(sta_stopped()))?
.map_err(StartError::Com)?;
Ok(sta)
Ok((sta, pin_status))
}
pub async fn execute(&self, command: Command) -> io::Result<Outcome> {
@@ -128,8 +131,9 @@ fn sta_stopped() -> io::Error {
fn run(
requests: mpsc::Receiver<Request>,
wake: Arc<OwnedHandle>,
ready: oneshot::Sender<Result<(), HRESULT>>,
ready: oneshot::Sender<Result<String, HRESULT>>,
finished: oneshot::Sender<usize>,
publisher: Publisher,
) {
let apartment = match Apartment::initialize() {
Ok(apartment) => apartment,
@@ -138,18 +142,20 @@ fn run(
return;
}
};
let mut proxy = match Proxy::activate() {
let pin = RecordInfoPin::load();
let mut proxy = match Proxy::activate(publisher) {
Ok(proxy) => proxy,
Err(error) => {
let _ = ready.send(Err(error));
return;
}
};
if ready.send(Ok(())).is_ok() {
if ready.send(Ok(RecordInfoPin::status(&pin))).is_ok() {
pump(&requests, &wake, &mut proxy);
}
let failures = proxy.cleanup();
drop(proxy);
drop(pin);
drop(apartment);
let _ = finished.send(failures);
}
@@ -206,8 +212,8 @@ impl Drop for Apartment {
}
}
// First eleven slots of the installed dual ILMXProxyServer interface. Slots
// 0–6 are IUnknown and IDispatch. The next four slots follow the installed
// First thirteen slots of the installed dual ILMXProxyServer interface. Slots
// 0–6 are IUnknown and IDispatch. The next six slots follow the installed
// interop assembly, with HRESULT and [out, retval] for the handle results.
#[repr(C)]
struct ProxyVtable {
@@ -220,15 +226,19 @@ struct ProxyVtable {
unregister: unsafe extern "system" fn(*mut c_void, i32) -> HRESULT,
add_item: unsafe extern "system" fn(*mut c_void, i32, BSTR, *mut i32) -> HRESULT,
remove_item: unsafe extern "system" fn(*mut c_void, i32, i32) -> HRESULT,
advise: unsafe extern "system" fn(*mut c_void, i32, i32) -> HRESULT,
unadvise: unsafe extern "system" fn(*mut c_void, i32, i32) -> HRESULT,
}
struct Proxy {
interface: NonNull<c_void>,
registrations: BTreeSet<i32>,
publisher: Publisher,
connection: Option<Connection>,
}
impl Proxy {
fn activate() -> Result<Self, HRESULT> {
fn activate(publisher: Publisher) -> Result<Self, HRESULT> {
let mut interface = null_mut();
// SAFETY: the output is for the exact IID declared by ProxyVtable.
check(unsafe {
@@ -240,10 +250,15 @@ impl Proxy {
&mut interface,
)
})?;
Ok(Self {
let mut proxy = Self {
interface: NonNull::new(interface).ok_or(0x8000_4003_u32 as i32)?,
registrations: BTreeSet::new(),
})
publisher,
connection: None,
};
// SAFETY: this STA owns the live proxy and its connection point.
proxy.connection = Some(unsafe { Connection::attach(interface, proxy.publisher.clone()) }?);
Ok(proxy)
}
fn execute(&mut self, command: Command) -> Outcome {
@@ -265,6 +280,7 @@ impl Proxy {
check(unsafe { (table.unregister)(object, server) })
.map_err(CommandError::HResult)?;
self.registrations.remove(&server);
self.publisher.unregister(server);
Ok(None)
}
Command::AddItem(server, definition) => {
@@ -279,6 +295,25 @@ impl Proxy {
self.require_registration(server)?;
check(unsafe { (table.remove_item)(object, server, item) })
.map_err(CommandError::HResult)?;
self.publisher.unadvise(server, item);
Ok(None)
}
Command::Advise(server, item) => {
self.require_registration(server)?;
// The COM call may publish the initial value before it returns.
let added = self.publisher.advise(server, item);
let status = unsafe { (table.advise)(object, server, item) };
if status < 0 && added {
self.publisher.unadvise(server, item);
}
check(status).map_err(CommandError::HResult)?;
Ok(None)
}
Command::UnAdvise(server, item) => {
self.require_registration(server)?;
check(unsafe { (table.unadvise)(object, server, item) })
.map_err(CommandError::HResult)?;
self.publisher.unadvise(server, item);
Ok(None)
}
}
@@ -293,7 +328,28 @@ impl Proxy {
}
fn cleanup(&mut self) -> usize {
let advice = self.publisher.take_advice();
let mut failures = 0;
if let Some(mut connection) = self.connection.take() {
if let Err(hr) = connection.detach() {
failures += 1;
eprintln!(
"MXAccess event sink detach failed (HRESULT 0x{:08X})",
hr as u32
);
}
}
for (server, item) in advice {
// SAFETY: the interface is still live on this STA.
let hr = unsafe { (self.vtable().unadvise)(self.interface.as_ptr(), server, item) };
if hr < 0 {
failures += 1;
eprintln!(
"MXAccess unadvise during shutdown failed (HRESULT 0x{:08X})",
hr as u32
);
}
}
for server in std::mem::take(&mut self.registrations) {
// SAFETY: the interface is still live on this STA.
let hr = unsafe { (self.vtable().unregister)(self.interface.as_ptr(), server) };
@@ -316,6 +372,7 @@ impl Proxy {
impl Drop for Proxy {
fn drop(&mut self) {
drop(self.connection.take());
// SAFETY: release the reference returned by CoCreateInstance on this STA.
unsafe { (self.vtable().release)(self.interface.as_ptr()) };
}
+545
View File
@@ -0,0 +1,545 @@
use std::collections::BTreeSet;
use std::ffi::c_void;
use std::ptr::{null_mut, NonNull};
use std::sync::{
atomic::{AtomicU32, Ordering},
Arc, Mutex,
};
use std::time::SystemTime;
use tokio::sync::{mpsc, watch};
use windows_sys::core::{IID_IUnknown, IUnknown_Vtbl, GUID, HRESULT, PWSTR};
use windows_sys::Win32::Foundation::{
DISP_E_BADPARAMCOUNT, DISP_E_EXCEPTION, DISP_E_MEMBERNOTFOUND, DISP_E_TYPEMISMATCH,
DISP_E_UNKNOWNNAME, E_NOINTERFACE, E_NOTIMPL, E_POINTER, S_OK,
};
use windows_sys::Win32::System::Com::{DISPPARAMS, EXCEPINFO};
use windows_sys::Win32::System::Ole::{GetRecordInfoFromGuids, LoadRegTypeLib};
use windows_sys::Win32::System::Variant::VARIANT;
use crate::automation::{dispatch_i32, dispatch_statuses, dispatch_timestamp, dispatch_value};
use crate::wire::mxaccess_gateway::v1::{
mx_event, MxEvent, MxEventFamily, OnDataChangeEvent, OnWriteCompleteEvent,
OperationCompleteEvent,
};
const EVENTS_IID: GUID = GUID::from_u128(0x848299b6_dd61_4a0d_a304_3947a564b89c);
const DISPATCH_IID: GUID = GUID::from_u128(0x00020400_0000_0000_c000_000000000046);
const CONNECTION_POINT_CONTAINER_IID: GUID =
GUID::from_u128(0xb196b284_bab4_101a_b69c_00aa00341d07);
const TYPELIB_ID: GUID = GUID::from_u128(0x77e896ec_b3e3_4de4_b96f_f32570164211);
const RECORD_ID: GUID = GUID::from_u128(0xa162d9e4_9019_42f3_a087_79264007e542);
#[derive(Clone, Copy)]
pub enum EventFault {
Overflow,
Conversion(&'static str),
}
#[derive(Clone)]
pub struct Publisher {
session: Arc<str>,
events: mpsc::Sender<MxEvent>,
faults: watch::Sender<Option<EventFault>>,
state: Arc<Mutex<PublisherState>>,
}
#[derive(Default)]
struct PublisherState {
advised: BTreeSet<(i32, i32)>,
last_sequence: u64,
}
pub fn event_channel(
session: &str,
capacity: usize,
) -> (
Publisher,
mpsc::Receiver<MxEvent>,
watch::Receiver<Option<EventFault>>,
) {
let (events, receiver) = mpsc::channel(capacity);
let (faults, fault_receiver) = watch::channel(None);
(
Publisher {
session: session.into(),
events,
faults,
state: Arc::default(),
},
receiver,
fault_receiver,
)
}
impl Publisher {
pub fn advise(&self, server: i32, item: i32) -> bool {
self.state.lock().unwrap().advised.insert((server, item))
}
pub fn unadvise(&self, server: i32, item: i32) {
self.state.lock().unwrap().advised.remove(&(server, item));
}
pub fn unregister(&self, server: i32) {
self.state
.lock()
.unwrap()
.advised
.retain(|(handle, _)| *handle != server);
}
pub fn take_advice(&self) -> BTreeSet<(i32, i32)> {
std::mem::take(&mut self.state.lock().unwrap().advised)
}
pub fn last_sequence(&self) -> u64 {
self.state.lock().unwrap().last_sequence
}
fn is_advised(&self, server: i32, item: i32) -> bool {
self.state.lock().unwrap().advised.contains(&(server, item))
}
fn report_fault(&self, fault: EventFault) {
self.faults.send_if_modified(|current| {
if current.is_some() {
return false;
}
*current = Some(fault);
true
});
}
fn publish(&self, mut event: MxEvent) {
let mut state = self.state.lock().unwrap();
event.session_id = self.session.to_string();
event.worker_timestamp = Some(SystemTime::now().into());
event.worker_sequence = state.last_sequence + 1;
match self.events.try_send(event) {
Ok(()) => state.last_sequence += 1,
Err(mpsc::error::TrySendError::Full(_)) => self.report_fault(EventFault::Overflow),
Err(mpsc::error::TrySendError::Closed(_)) => {}
}
}
}
#[repr(C)]
struct ConnectionPointContainerVtable {
base: IUnknown_Vtbl,
enum_connection_points: usize,
find_connection_point:
unsafe extern "system" fn(*mut c_void, *const GUID, *mut *mut c_void) -> HRESULT,
}
#[repr(C)]
struct ConnectionPointVtable {
base: IUnknown_Vtbl,
get_connection_interface: usize,
get_connection_point_container: usize,
advise: unsafe extern "system" fn(*mut c_void, *mut c_void, *mut u32) -> HRESULT,
unadvise: unsafe extern "system" fn(*mut c_void, u32) -> HRESULT,
}
pub struct Connection {
point: ComReference,
cookie: Option<u32>,
}
impl Connection {
// The caller supplies the live LMXProxy interface on the owning STA.
pub unsafe fn attach(proxy: *mut c_void, publisher: Publisher) -> Result<Self, HRESULT> {
let mut container = null_mut();
let unknown = unsafe { vtable::<IUnknown_Vtbl>(proxy) };
check(unsafe {
(unknown.QueryInterface)(proxy, &CONNECTION_POINT_CONTAINER_IID, &mut container)
})?;
let container = ComReference::new(container)?;
let mut point = null_mut();
let table = unsafe { vtable::<ConnectionPointContainerVtable>(container.as_ptr()) };
check(unsafe {
(table.find_connection_point)(container.as_ptr(), &EVENTS_IID, &mut point)
})?;
let point = ComReference::new(point)?;
let sink = Box::new(Sink {
table: &SINK_VTABLE,
reference_count: AtomicU32::new(1),
publisher,
});
let sink = ComReference::new(Box::into_raw(sink).cast())?;
let mut cookie = 0;
let table = unsafe { vtable::<ConnectionPointVtable>(point.as_ptr()) };
check(unsafe { (table.advise)(point.as_ptr(), sink.as_ptr(), &mut cookie) })?;
Ok(Self {
point,
cookie: Some(cookie),
})
}
pub fn detach(&mut self) -> Result<(), HRESULT> {
if let Some(cookie) = self.cookie.take() {
// SAFETY: the cookie was returned by this live connection point on this STA.
let pointer = self.point.as_ptr();
let table = unsafe { vtable::<ConnectionPointVtable>(pointer) };
check(unsafe { (table.unadvise)(pointer, cookie) })?;
}
Ok(())
}
}
impl Drop for Connection {
fn drop(&mut self) {
let _ = self.detach();
}
}
struct ComReference(NonNull<c_void>);
impl ComReference {
fn new(pointer: *mut c_void) -> Result<Self, HRESULT> {
NonNull::new(pointer).map(Self).ok_or(E_POINTER)
}
fn as_ptr(&self) -> *mut c_void {
self.0.as_ptr()
}
}
impl Drop for ComReference {
fn drop(&mut self) {
// SAFETY: this holds one owned COM reference and runs on its STA.
let pointer = self.as_ptr();
unsafe { (vtable::<IUnknown_Vtbl>(pointer).Release)(pointer) };
}
}
unsafe fn vtable<V>(pointer: *mut c_void) -> &'static V {
unsafe { &**pointer.cast::<*const V>() }
}
pub struct RecordInfoPin {
_library: ComReference,
_record: ComReference,
}
impl RecordInfoPin {
pub fn load() -> Result<Self, HRESULT> {
let mut library = null_mut();
let mut record = null_mut();
// SAFETY: these are the verified registered typelib and record IDs of MXAccess 3.2.
check(unsafe { LoadRegTypeLib(&TYPELIB_ID, 3, 2, 0, &mut library) })?;
let library = ComReference::new(library)?;
check(unsafe { GetRecordInfoFromGuids(&TYPELIB_ID, 3, 2, 0, &RECORD_ID, &mut record) })?;
Ok(Self {
_library: library,
_record: ComReference::new(record)?,
})
}
pub fn status(result: &Result<Self, HRESULT>) -> String {
match result {
Ok(_) => "pinned {77e896ec-b3e3-4de4-b96f-f32570164211} v3.2 record {a162d9e4-9019-42f3-a087-79264007e542}".into(),
Err(hr) => format!("MXSTATUS_PROXY pin failed (HRESULT 0x{:08X})", *hr as u32),
}
}
}
fn check(hr: HRESULT) -> Result<(), HRESULT> {
if hr < 0 {
Err(hr)
} else {
Ok(())
}
}
#[repr(C)]
struct Sink {
table: &'static DispatchVtable,
reference_count: AtomicU32,
publisher: Publisher,
}
#[repr(C)]
struct DispatchVtable {
base: IUnknown_Vtbl,
type_info_count: unsafe extern "system" fn(*mut c_void, *mut u32) -> HRESULT,
type_info: unsafe extern "system" fn(*mut c_void, u32, u32, *mut *mut c_void) -> HRESULT,
names: unsafe extern "system" fn(
*mut c_void,
*const GUID,
*const PWSTR,
u32,
u32,
*mut i32,
) -> HRESULT,
invoke: unsafe extern "system" fn(
*mut c_void,
i32,
*const GUID,
u32,
u16,
*mut DISPPARAMS,
*mut VARIANT,
*mut EXCEPINFO,
*mut u32,
) -> HRESULT,
}
static SINK_VTABLE: DispatchVtable = DispatchVtable {
base: IUnknown_Vtbl {
QueryInterface: query_interface,
AddRef: add_ref,
Release: release,
},
type_info_count,
type_info,
names,
invoke,
};
unsafe extern "system" fn query_interface(
this: *mut c_void,
iid: *const GUID,
result: *mut *mut c_void,
) -> HRESULT {
let Some(result) = (unsafe { result.as_mut() }) else {
return E_POINTER;
};
*result = null_mut();
let Some(iid) = (unsafe { iid.as_ref() }) else {
return E_POINTER;
};
if [EVENTS_IID, DISPATCH_IID, IID_IUnknown]
.iter()
.any(|supported| {
supported.data1 == iid.data1
&& supported.data2 == iid.data2
&& supported.data3 == iid.data3
&& supported.data4 == iid.data4
})
{
unsafe { add_ref(this) };
*result = this;
S_OK
} else {
E_NOINTERFACE
}
}
unsafe extern "system" fn add_ref(this: *mut c_void) -> u32 {
let sink = unsafe { &*this.cast::<Sink>() };
sink.reference_count.fetch_add(1, Ordering::Relaxed) + 1
}
unsafe extern "system" fn release(this: *mut c_void) -> u32 {
let sink = unsafe { &*this.cast::<Sink>() };
let remaining = sink.reference_count.fetch_sub(1, Ordering::AcqRel) - 1;
if remaining == 0 {
unsafe { drop(Box::from_raw(this.cast::<Sink>())) };
}
remaining
}
unsafe extern "system" fn type_info_count(_: *mut c_void, count: *mut u32) -> HRESULT {
let Some(count) = (unsafe { count.as_mut() }) else {
return E_POINTER;
};
*count = 0;
S_OK
}
unsafe extern "system" fn type_info(
_: *mut c_void,
_: u32,
_: u32,
output: *mut *mut c_void,
) -> HRESULT {
if let Some(output) = unsafe { output.as_mut() } {
*output = null_mut();
}
E_NOTIMPL
}
unsafe extern "system" fn names(
_: *mut c_void,
_: *const GUID,
_: *const PWSTR,
_: u32,
_: u32,
_: *mut i32,
) -> HRESULT {
DISP_E_UNKNOWNNAME
}
unsafe extern "system" fn invoke(
this: *mut c_void,
member: i32,
_: *const GUID,
_: u32,
_: u16,
parameters: *mut DISPPARAMS,
_: *mut VARIANT,
_: *mut EXCEPINFO,
_: *mut u32,
) -> HRESULT {
let sink = unsafe { &*this.cast::<Sink>() };
// Panics must never cross the COM ABI.
match std::panic::catch_unwind(|| unsafe { sink.on_dispatch(member, parameters) }) {
Ok(hr) => hr,
Err(_) => {
sink.publisher
.report_fault(EventFault::Conversion("panic in MXAccess event sink"));
DISP_E_EXCEPTION
}
}
}
impl Sink {
unsafe fn on_dispatch(&self, member: i32, parameters: *const DISPPARAMS) -> HRESULT {
let (count, family, body) = match member {
1 => (
6,
MxEventFamily::OnDataChange,
mx_event::Body::OnDataChange(OnDataChangeEvent {}),
),
2 => (
3,
MxEventFamily::OnWriteComplete,
mx_event::Body::OnWriteComplete(OnWriteCompleteEvent {}),
),
3 => (
3,
MxEventFamily::OperationComplete,
mx_event::Body::OperationComplete(OperationCompleteEvent {}),
),
_ => return DISP_E_MEMBERNOTFOUND,
};
let Some(parameters) = (unsafe { parameters.as_ref() }) else {
return E_POINTER;
};
if parameters.cArgs as usize != count || parameters.rgvarg.is_null() {
self.publisher.report_fault(EventFault::Conversion(
"unexpected MXAccess callback argument count",
));
return DISP_E_BADPARAMCOUNT;
}
// IDispatch packs its positional arguments in reverse order. LMXProxy
// puts them at four-byte aligned addresses on x86, so copy them before
// forming Rust references to the eight-byte-aligned VARIANT type.
let mut args = [VARIANT::default(); 6];
for (index, argument) in args[..count].iter_mut().enumerate() {
*argument = unsafe { parameters.rgvarg.add(index).read_unaligned() };
}
let (Some(server), Some(item)) = (unsafe { dispatch_i32(&args[count - 1]) }, unsafe {
dispatch_i32(&args[count - 2])
}) else {
self.publisher.report_fault(EventFault::Conversion(
"unexpected MXAccess callback handle types",
));
return DISP_E_TYPEMISMATCH;
};
if member == 1 && !self.publisher.is_advised(server, item) {
return S_OK;
}
let statuses = match unsafe { dispatch_statuses(&args[0]) } {
Ok(statuses) => statuses,
Err(error) => {
self.publisher.report_fault(EventFault::Conversion(error));
return DISP_E_TYPEMISMATCH;
}
};
let mut event = MxEvent {
family: family as i32,
server_handle: server,
item_handle: item,
statuses,
body: Some(body),
..Default::default()
};
if member == 1 {
let Some(quality) = (unsafe { dispatch_i32(&args[2]) }) else {
self.publisher
.report_fault(EventFault::Conversion("unexpected MXAccess quality type"));
return DISP_E_TYPEMISMATCH;
};
event.quality = quality;
event.value = Some(unsafe { dispatch_value(&args[3]) });
event.source_timestamp = unsafe { dispatch_timestamp(&args[1]) };
}
self.publisher.publish(event);
S_OK
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::wire::mxaccess_gateway::v1::mx_value;
use std::mem::size_of;
use windows_sys::Win32::System::Variant::VT_I4;
#[test]
fn copies_x86_dispatch_arguments_and_filters_unadvised_items() {
#[repr(align(8))]
struct PackedArguments([u8; 4 + 6 * size_of::<VARIANT>()]);
let (publisher, mut events, faults) = event_channel("session", 1);
let sink = Sink {
table: &SINK_VTABLE,
reference_count: AtomicU32::new(1),
publisher,
};
let mut packed = PackedArguments([0; 4 + 6 * size_of::<VARIANT>()]);
let values = [
VARIANT::default(),
VARIANT::default(),
integer(192),
integer(42),
integer(7),
integer(5),
];
// SAFETY: each of the six complete VARIANTs fits the byte buffer,
// whose four-byte offset reproduces the native callback alignment.
let parameters = unsafe {
let args = packed.0.as_mut_ptr().add(4).cast::<VARIANT>();
for (index, value) in values.into_iter().enumerate() {
args.add(index).write_unaligned(value);
}
DISPPARAMS {
rgvarg: args,
cArgs: 6,
..Default::default()
}
};
assert!(sink.publisher.advise(5, 7));
assert_eq!(unsafe { sink.on_dispatch(1, &parameters) }, S_OK);
assert_eq!(unsafe { sink.on_dispatch(1, &parameters) }, S_OK);
assert!(matches!(*faults.borrow(), Some(EventFault::Overflow)));
assert_eq!(sink.publisher.last_sequence(), 1);
let event = events.try_recv().unwrap();
assert_eq!(event.session_id, "session");
assert_eq!(event.worker_sequence, 1);
assert_eq!(event.quality, 192);
assert!(matches!(
event.value.unwrap().kind,
Some(mx_value::Kind::Int32Value(42))
));
sink.publisher.unadvise(5, 7);
assert_eq!(unsafe { sink.on_dispatch(1, &parameters) }, S_OK);
assert!(matches!(
events.try_recv(),
Err(mpsc::error::TryRecvError::Empty)
));
}
fn integer(value: i32) -> VARIANT {
let mut result = VARIANT::default();
result.Anonymous.Anonymous.vt = VT_I4;
result.Anonymous.Anonymous.Anonymous.lVal = value;
result
}
}
+136 -19
View File
@@ -2,23 +2,27 @@ use std::collections::HashMap;
use std::io;
use std::time::{Duration, SystemTime};
use prost::Message;
use prost_types::Timestamp;
use tokio::io::{split, AsyncWrite};
use tokio::net::windows::named_pipe::{ClientOptions, NamedPipeClient};
use tokio::sync::mpsc;
use tokio::sync::{mpsc, watch};
use tokio::time::{interval, sleep, timeout, Instant, MissedTickBehavior};
use crate::automation::int32;
use crate::mxaccess::{Command, CommandError, Sta, StartError, CLASS_ID, PROG_ID};
use crate::mxevent::{event_channel, EventFault, Publisher};
use crate::wire::{
self,
mxaccess_gateway::v1::{
mx_command, mx_command_reply, mx_value, AddItemReply, DrainEventsReply, MxCommand,
MxCommandKind, MxCommandReply, MxDataType, MxValue, ProtocolStatus, ProtocolStatusCode,
RegisterReply, SessionState, SessionStateReply, WorkerInfoReply,
mx_command, mx_command_reply, AddItemReply, DrainEventsReply, MxCommand, MxCommandKind,
MxCommandReply, MxEvent, ProtocolStatus, ProtocolStatusCode, RegisterReply, SessionState,
SessionStateReply, WorkerInfoReply,
},
mxaccess_worker::v1::{
GatewayHello, WorkerCommand, WorkerCommandReply, WorkerFault, WorkerFaultCategory,
WorkerHeartbeat, WorkerHello, WorkerReady, WorkerShutdownAck, WorkerState,
GatewayHello, WorkerCommand, WorkerCommandReply, WorkerEvent, WorkerFault,
WorkerFaultCategory, WorkerHeartbeat, WorkerHello, WorkerReady, WorkerShutdownAck,
WorkerState,
},
Body, Writer, DEFAULT_MAX, VERSION,
};
@@ -65,6 +69,7 @@ struct Options {
heartbeat_interval: Duration,
sta_grace: Duration,
command_ceiling: Duration,
event_capacity: usize,
}
impl Options {
@@ -112,6 +117,11 @@ impl Options {
heartbeat_interval: env_duration("MXGATEWAY_WORKER_HEARTBEAT_SEND_INTERVAL_MS", 5000),
sta_grace: env_duration("MXGATEWAY_WORKER_HEARTBEAT_GRACE_MS", 15000),
command_ceiling: env_duration("MXGATEWAY_WORKER_HEARTBEAT_STUCK_CEILING_MS", 75000),
event_capacity: std::env::var("MXGATEWAY_EVENT_QUEUE_CAPACITY")
.ok()
.and_then(|value| value.parse().ok())
.filter(|value| (1_000..=1_000_000).contains(value))
.unwrap_or(10_000),
})
}
}
@@ -175,8 +185,9 @@ pub async fn run() -> Result<(), Error> {
}
};
let sta = match Sta::start().await {
Ok(sta) => sta,
let mut events = EventStream::new(&options);
let (sta, pin_status) = match Sta::start(events.publisher.clone()).await {
Ok(started) => started,
Err(error) => {
let (hresult, diagnostic) = match error {
StartError::Io(error) => (None, error.to_string()),
@@ -206,7 +217,7 @@ pub async fn run() -> Result<(), Error> {
mxaccess_progid: PROG_ID.into(),
mxaccess_clsid: CLASS_ID.into(),
ready_timestamp: Some(now()),
record_info_pin_status: String::new(),
record_info_pin_status: pin_status,
}),
max,
)
@@ -225,7 +236,7 @@ pub async fn run() -> Result<(), Error> {
}
});
let result = command_loop(&options, max, &sta, &mut writer, &mut frames).await;
let result = command_loop(&options, max, &sta, &mut writer, &mut frames, &mut events).await;
// Keep the read half alive during graceful shutdown so the gateway can
// finish a control write before reading the ack.
let acknowledgement = match result {
@@ -299,11 +310,43 @@ async fn command_loop<W: AsyncWrite + Unpin>(
sta: &Sta,
writer: &mut Writer<W>,
frames: &mut mpsc::Receiver<io::Result<wire::WorkerEnvelope>>,
events: &mut EventStream,
) -> Result<Duration, Error> {
let mut heartbeat = interval(options.heartbeat_interval);
heartbeat.set_missed_tick_behavior(MissedTickBehavior::Delay);
loop {
let callback_fault = *events.faults.borrow_and_update();
if let Some(failure) = callback_fault {
let (category, message, exit_code) = match failure {
EventFault::Overflow => (
WorkerFaultCategory::QueueOverflow,
"MXAccess event backlog exceeded the outbound queue capacity",
8,
),
EventFault::Conversion(message) => (
WorkerFaultCategory::MxaccessEventConversionFailed,
message,
1,
),
};
fault(writer, &options.session, max, category, None, message).await;
return Err(Error(exit_code, message.into()));
}
tokio::select! {
_ = events.faults.changed() => continue,
next = recv_event(&mut events.pending, &mut events.receiver) => {
let event = next.ok_or_else(|| Error(1, "MXAccess event channel closed".into()))?;
let result = writer.send(
&options.session, "", Body::WorkerEvent(WorkerEvent { event: Some(event) }), max,
).await;
if let Err(error) = result {
if error.kind() == io::ErrorKind::InvalidData {
fault(writer, &options.session, max, WorkerFaultCategory::ProtocolViolation, None,
"MXAccess event exceeds the negotiated frame maximum").await;
}
return Err(error.into());
}
}
frame = frames.recv() => {
let frame = frame.ok_or_else(|| Error(5, "Worker pipe reader exited".into()))??;
let correlation = frame.correlation_id;
@@ -312,7 +355,7 @@ async fn command_loop<W: AsyncWrite + Unpin>(
let kind = command.as_ref().map_or(0, |command| command.kind);
let execution = timeout(
options.command_ceiling,
execute(sta, command, &options.session, &correlation),
execute(sta, command, &options.session, &correlation, events, max),
).await;
let mut reply = match execution {
Ok(Ok(reply)) => reply,
@@ -364,6 +407,8 @@ async fn command_loop<W: AsyncWrite + Unpin>(
worker_process_id: pid(),
state: WorkerState::Ready as i32,
last_sta_activity_timestamp: Some(now()),
outbound_event_queue_depth: events.depth() as u32,
last_event_sequence: events.publisher.last_sequence(),
..Default::default()
}), max).await?;
}
@@ -376,6 +421,8 @@ async fn execute(
command: Option<MxCommand>,
session: &str,
correlation: &str,
events: &mut EventStream,
max: usize,
) -> Result<MxCommandReply, Error> {
use mx_command::Payload;
use mx_command_reply::Payload as Reply;
@@ -408,6 +455,12 @@ async fn execute(
(Kind::RemoveItem, Some(Payload::RemoveItem(request))) => {
Command::RemoveItem(request.server_handle, request.item_handle)
}
(Kind::Advise, Some(Payload::Advise(request))) => {
Command::Advise(request.server_handle, request.item_handle)
}
(Kind::UnAdvise, Some(Payload::UnAdvise(request))) => {
Command::UnAdvise(request.server_handle, request.item_handle)
}
(Kind::Ping, Some(Payload::Ping(request))) => {
reply.diagnostic_message = request.message;
return Ok(reply);
@@ -429,8 +482,12 @@ async fn execute(
}));
return Ok(reply);
}
(Kind::DrainEvents, None | Some(Payload::DrainEvents(_))) => {
reply.payload = Some(Reply::DrainEvents(DrainEventsReply::default()));
(Kind::DrainEvents, payload @ (None | Some(Payload::DrainEvents(_)))) => {
let requested = match payload {
Some(Payload::DrainEvents(request)) => request.max_events,
_ => 0,
};
reply.payload = Some(Reply::DrainEvents(events.drain(requested, max)));
return Ok(reply);
}
_ => {
@@ -444,12 +501,7 @@ async fn execute(
};
match sta.execute(native).await.map_err(Error::sta)? {
Ok(Some(handle)) => {
reply.return_value = Some(MxValue {
data_type: MxDataType::Integer as i32,
variant_type: "VT_I4".into(),
kind: Some(mx_value::Kind::Int32Value(handle)),
..Default::default()
});
reply.return_value = Some(int32(handle));
reply.payload = Some(match kind {
Kind::Register => Reply::Register(RegisterReply {
server_handle: handle,
@@ -477,6 +529,71 @@ async fn execute(
Ok(reply)
}
struct EventStream {
publisher: Publisher,
receiver: mpsc::Receiver<MxEvent>,
faults: watch::Receiver<Option<EventFault>>,
pending: Option<MxEvent>,
}
impl EventStream {
fn new(options: &Options) -> Self {
let (publisher, receiver, faults) = event_channel(&options.session, options.event_capacity);
Self {
publisher,
receiver,
faults,
pending: None,
}
}
fn depth(&self) -> usize {
self.receiver.len() + usize::from(self.pending.is_some())
}
fn drain(&mut self, requested: u32, max_frame: usize) -> DrainEventsReply {
const LIMIT: u32 = 10_000;
let count = if requested == 0 {
LIMIT
} else {
requested.min(LIMIT)
};
// The C# worker reserves space for the pipe and public gRPC envelopes.
let mut bytes_remaining = max_frame.saturating_sub(2 * 64 * 1024).max(max_frame / 2);
let mut events = Vec::new();
for _ in 0..count {
let Some(event) = self
.pending
.take()
.or_else(|| self.receiver.try_recv().ok())
else {
break;
};
let size = event.encoded_len();
let cost = 1 + prost::length_delimiter_len(size) + size;
if cost > bytes_remaining {
self.pending = Some(event);
break;
}
bytes_remaining -= cost;
events.push(event);
}
DrainEventsReply { events }
}
}
// Receiver::recv is cancellation-safe. A pending event returns immediately
// when this branch is polled, so select never cancels after taking it.
async fn recv_event(
pending: &mut Option<MxEvent>,
receiver: &mut mpsc::Receiver<MxEvent>,
) -> Option<MxEvent> {
match pending.take() {
Some(event) => Some(event),
None => receiver.recv().await,
}
}
fn command_reply(session: &str, correlation: &str, kind: i32) -> MxCommandReply {
MxCommandReply {
session_id: session.into(),
@@ -9,13 +9,13 @@ use tokio::io::{split, AsyncRead, AsyncWrite};
use tokio::net::windows::named_pipe::ServerOptions;
use tokio::time::{sleep, timeout};
use wire::mxaccess_gateway::v1::{
mx_command, mx_command_reply, AddItemCommand, MxCommand, MxCommandKind, MxCommandReply,
ProtocolStatusCode, RegisterCommand, RemoveItemCommand, UnregisterCommand,
mx_command, mx_command_reply, AddItemCommand, AdviseCommand, MxCommand, MxCommandKind,
MxCommandReply, ProtocolStatusCode, RegisterCommand, RemoveItemCommand, UnregisterCommand,
};
use wire::mxaccess_worker::v1::{GatewayHello, WorkerCommand, WorkerShutdown};
use wire::{Body, Writer, DEFAULT_MAX, VERSION};
const DEADLINE: Duration = Duration::from_secs(20);
const DEADLINE: Duration = Duration::from_secs(40);
#[tokio::test]
#[ignore = "requires a registered 32-bit System Platform MXAccess installation"]
@@ -141,8 +141,9 @@ async fn activates_registers_and_shuts_down_over_a_windows_pipe() {
)
.await;
// Leave a registration active to exercise the worker's shutdown cleanup.
invoke(
// Leave a registration and, when a live item is configured, an advice
// active to check that the shutdown acknowledgement is sent after cleanup.
let cleanup_registration = invoke(
&mut reader,
&mut writer,
session,
@@ -153,6 +154,40 @@ async fn activates_registers_and_shuts_down_over_a_windows_pipe() {
}),
)
.await;
if let Ok(definition) = std::env::var("MXGATEWAY_RUST_SMOKE_ITEM") {
let Some(mx_command_reply::Payload::Register(registration)) =
cleanup_registration.payload
else {
panic!("missing cleanup registration handle");
};
let added = invoke(
&mut reader,
&mut writer,
session,
"add-for-cleanup",
MxCommandKind::AddItem,
mx_command::Payload::AddItem(AddItemCommand {
server_handle: registration.server_handle,
item_definition: definition,
}),
)
.await;
let Some(mx_command_reply::Payload::AddItem(item)) = added.payload else {
panic!("missing live item handle");
};
invoke(
&mut reader,
&mut writer,
session,
"advise-for-cleanup",
MxCommandKind::Advise,
mx_command::Payload::Advise(AdviseCommand {
server_handle: registration.server_handle,
item_handle: item.item_handle,
}),
)
.await;
}
writer
.send(
session,
@@ -164,7 +199,7 @@ async fn activates_registers_and_shuts_down_over_a_windows_pipe() {
.unwrap();
loop {
match read_body(&mut reader, session).await {
Body::WorkerHeartbeat(_) => {}
Body::WorkerHeartbeat(_) | Body::WorkerEvent(_) => {}
Body::WorkerShutdownAck(ack) => {
let status = ack.status.unwrap();
assert_eq!(status.code(), ProtocolStatusCode::Ok);