Stream live MXAccess advice events from the Rust worker
This commit is contained in:
@@ -1,9 +1,15 @@
|
|||||||
using System.Collections.Concurrent;
|
using System.Collections.Concurrent;
|
||||||
using System.Diagnostics;
|
using System.Diagnostics;
|
||||||
using System.Diagnostics.CodeAnalysis;
|
using System.Diagnostics.CodeAnalysis;
|
||||||
|
using System.Net;
|
||||||
using System.Text;
|
using System.Text;
|
||||||
using Google.Protobuf.WellKnownTypes;
|
using Google.Protobuf.WellKnownTypes;
|
||||||
using Grpc.Core;
|
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.Logging;
|
||||||
using Microsoft.Extensions.Options;
|
using Microsoft.Extensions.Options;
|
||||||
using ZB.MOM.WW.MxGateway.Contracts;
|
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.Server.Workers;
|
||||||
using ZB.MOM.WW.MxGateway.IntegrationTests.TestSupport;
|
using ZB.MOM.WW.MxGateway.IntegrationTests.TestSupport;
|
||||||
using Xunit.Abstractions;
|
using Xunit.Abstractions;
|
||||||
|
using SessionOptions = ZB.MOM.WW.MxGateway.Server.Configuration.SessionOptions;
|
||||||
|
|
||||||
namespace ZB.MOM.WW.MxGateway.IntegrationTests;
|
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>
|
/// <summary>
|
||||||
/// Verifies that a Write command round-trips through live MXAccess against an advised item
|
/// 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
|
/// and that the worker emits a matching <see cref="MxEventFamily.OnWriteComplete"/> event
|
||||||
|
|||||||
@@ -13,9 +13,13 @@ tokio = { version = "1.48", features = ["io-util"] }
|
|||||||
tokio = { version = "1.48", features = ["macros", "net", "rt", "sync", "time"] }
|
tokio = { version = "1.48", features = ["macros", "net", "rt", "sync", "time"] }
|
||||||
windows-sys = { version = "0.61", features = [
|
windows-sys = { version = "0.61", features = [
|
||||||
"Win32_Foundation",
|
"Win32_Foundation",
|
||||||
|
"Win32_Globalization",
|
||||||
"Win32_Security",
|
"Win32_Security",
|
||||||
"Win32_System_Com",
|
"Win32_System_Com",
|
||||||
|
"Win32_System_Ole",
|
||||||
"Win32_System_Threading",
|
"Win32_System_Threading",
|
||||||
|
"Win32_System_Time",
|
||||||
|
"Win32_System_Variant",
|
||||||
"Win32_UI_WindowsAndMessaging",
|
"Win32_UI_WindowsAndMessaging",
|
||||||
] }
|
] }
|
||||||
|
|
||||||
|
|||||||
@@ -6,15 +6,21 @@ schemas at build time.
|
|||||||
|
|
||||||
The worker authenticates the launch nonce, negotiates a frame limit, activates
|
The worker authenticates the launch nonce, negotiates a frame limit, activates
|
||||||
LMXProxy on a dedicated message-pumping STA, and reports readiness and heartbeats.
|
LMXProxy on a dedicated message-pumping STA, and reports readiness and heartbeats.
|
||||||
It supports Register, Unregister, AddItem, RemoveItem, and the worker diagnostic
|
It supports Register, Unregister, AddItem, RemoveItem, Advise, UnAdvise, and the
|
||||||
commands. Shutdown unregisters any remaining clients before releasing COM. The
|
worker diagnostic commands. The worker uses the base MXAccess COM connection
|
||||||
existing C# worker is the gateway default.
|
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
|
Event conversion supports standard Automation scalar values and homogeneous
|
||||||
integer handles, writes, bulk commands, alarms, and record-info pinning remain to
|
arrays of those types. Other variant types are reported as unknown with the
|
||||||
be implemented. Unsupported commands return `InvalidRequest`. The prototype
|
Automation type in the diagnostic. Writes, buffered or supervisory advice,
|
||||||
serializes commands and does not interrupt COM calls on cancellation. If a call
|
bulk commands, and alarms remain to be implemented. Unsupported commands
|
||||||
exceeds the STA timeout, the worker faults the session and exits.
|
return `InvalidRequest`. The worker serializes commands. If a COM call exceeds
|
||||||
|
the STA timeout, the worker faults the session and exits.
|
||||||
|
|
||||||
## Build and test
|
## 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
|
shutdown. It runs without a gateway service. Portable framing tests also run
|
||||||
with `cargo test --locked` on macOS and Linux.
|
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
|
## COM interface evidence
|
||||||
|
|
||||||
The native adapter uses the dual `ILMXProxyServer` interface from the installed
|
The native adapter uses the dual `ILMXProxyServer` interface from the installed
|
||||||
`ArchestrA.MxAccess` 3.2.0.0 assembly. REA inspection confirmed the declaration
|
`ArchestrA.MxAccess` 3.2.0.0 assembly. REA inspection confirmed the declaration
|
||||||
order and managed signatures for Register, Unregister, AddItem, and RemoveItem.
|
order and managed signatures for Register, Unregister, AddItem, and RemoveItem.
|
||||||
Windows reflection confirmed the interface IID, dual-interface flag, DISPIDs, and
|
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
|
- Assembly SHA-256
|
||||||
`cba8b607305ee0c70ca38b09eca645ae3b98c35a7b78ec051eb4381f48d9e0b1`
|
`cba8b607305ee0c70ca38b09eca645ae3b98c35a7b78ec051eb4381f48d9e0b1`
|
||||||
- REA managed member evidence
|
- REA managed member evidence
|
||||||
`ev_78053da509335e3e3749b8e6bb020f28c45255b54d910546659c6760eb52160b`
|
`ev_78053da509335e3e3749b8e6bb020f28c45255b54d910546659c6760eb52160b`
|
||||||
|
- REA event member evidence
|
||||||
|
`ev_97162abcd831b2d84b5b43fb72cd9876252bbe3bb0af5c4673a6954911500e54`
|
||||||
|
|||||||
@@ -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]);
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -1,9 +1,13 @@
|
|||||||
#[cfg(all(windows, not(target_arch = "x86")))]
|
#[cfg(all(windows, not(target_arch = "x86")))]
|
||||||
compile_error!("The MXAccess COM server requires a 32-bit x86 Windows worker.");
|
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"))]
|
#[cfg(all(windows, target_arch = "x86"))]
|
||||||
mod mxaccess;
|
mod mxaccess;
|
||||||
#[cfg(all(windows, target_arch = "x86"))]
|
#[cfg(all(windows, target_arch = "x86"))]
|
||||||
|
mod mxevent;
|
||||||
|
#[cfg(all(windows, target_arch = "x86"))]
|
||||||
mod session;
|
mod session;
|
||||||
#[cfg(any(windows, test))]
|
#[cfg(any(windows, test))]
|
||||||
mod wire;
|
mod wire;
|
||||||
|
|||||||
@@ -1,3 +1,4 @@
|
|||||||
|
use crate::mxevent::{Connection, Publisher, RecordInfoPin};
|
||||||
use std::collections::BTreeSet;
|
use std::collections::BTreeSet;
|
||||||
use std::ffi::c_void;
|
use std::ffi::c_void;
|
||||||
use std::io;
|
use std::io;
|
||||||
@@ -29,6 +30,8 @@ pub enum Command {
|
|||||||
Unregister(i32),
|
Unregister(i32),
|
||||||
AddItem(i32, String),
|
AddItem(i32, String),
|
||||||
RemoveItem(i32, i32),
|
RemoveItem(i32, i32),
|
||||||
|
Advise(i32, i32),
|
||||||
|
UnAdvise(i32, i32),
|
||||||
}
|
}
|
||||||
|
|
||||||
pub enum CommandError {
|
pub enum CommandError {
|
||||||
@@ -55,7 +58,7 @@ pub struct Sta {
|
|||||||
}
|
}
|
||||||
|
|
||||||
impl 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.
|
// SAFETY: unnamed auto-reset event. Ownership transfers to OwnedHandle.
|
||||||
let event = unsafe { CreateEventW(null(), 0, 0, null()) };
|
let event = unsafe { CreateEventW(null(), 0, 0, null()) };
|
||||||
if event.is_null() {
|
if event.is_null() {
|
||||||
@@ -68,7 +71,7 @@ impl Sta {
|
|||||||
let thread_wake = Arc::clone(&wake);
|
let thread_wake = Arc::clone(&wake);
|
||||||
thread::Builder::new()
|
thread::Builder::new()
|
||||||
.name("mxgateway-sta".into())
|
.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)?;
|
.map_err(StartError::Io)?;
|
||||||
|
|
||||||
let sta = Self {
|
let sta = Self {
|
||||||
@@ -76,11 +79,11 @@ impl Sta {
|
|||||||
wake,
|
wake,
|
||||||
stopped: Some(stopped),
|
stopped: Some(stopped),
|
||||||
};
|
};
|
||||||
startup
|
let pin_status = startup
|
||||||
.await
|
.await
|
||||||
.map_err(|_| StartError::Io(sta_stopped()))?
|
.map_err(|_| StartError::Io(sta_stopped()))?
|
||||||
.map_err(StartError::Com)?;
|
.map_err(StartError::Com)?;
|
||||||
Ok(sta)
|
Ok((sta, pin_status))
|
||||||
}
|
}
|
||||||
|
|
||||||
pub async fn execute(&self, command: Command) -> io::Result<Outcome> {
|
pub async fn execute(&self, command: Command) -> io::Result<Outcome> {
|
||||||
@@ -128,8 +131,9 @@ fn sta_stopped() -> io::Error {
|
|||||||
fn run(
|
fn run(
|
||||||
requests: mpsc::Receiver<Request>,
|
requests: mpsc::Receiver<Request>,
|
||||||
wake: Arc<OwnedHandle>,
|
wake: Arc<OwnedHandle>,
|
||||||
ready: oneshot::Sender<Result<(), HRESULT>>,
|
ready: oneshot::Sender<Result<String, HRESULT>>,
|
||||||
finished: oneshot::Sender<usize>,
|
finished: oneshot::Sender<usize>,
|
||||||
|
publisher: Publisher,
|
||||||
) {
|
) {
|
||||||
let apartment = match Apartment::initialize() {
|
let apartment = match Apartment::initialize() {
|
||||||
Ok(apartment) => apartment,
|
Ok(apartment) => apartment,
|
||||||
@@ -138,18 +142,20 @@ fn run(
|
|||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
let mut proxy = match Proxy::activate() {
|
let pin = RecordInfoPin::load();
|
||||||
|
let mut proxy = match Proxy::activate(publisher) {
|
||||||
Ok(proxy) => proxy,
|
Ok(proxy) => proxy,
|
||||||
Err(error) => {
|
Err(error) => {
|
||||||
let _ = ready.send(Err(error));
|
let _ = ready.send(Err(error));
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
if ready.send(Ok(())).is_ok() {
|
if ready.send(Ok(RecordInfoPin::status(&pin))).is_ok() {
|
||||||
pump(&requests, &wake, &mut proxy);
|
pump(&requests, &wake, &mut proxy);
|
||||||
}
|
}
|
||||||
let failures = proxy.cleanup();
|
let failures = proxy.cleanup();
|
||||||
drop(proxy);
|
drop(proxy);
|
||||||
|
drop(pin);
|
||||||
drop(apartment);
|
drop(apartment);
|
||||||
let _ = finished.send(failures);
|
let _ = finished.send(failures);
|
||||||
}
|
}
|
||||||
@@ -206,8 +212,8 @@ impl Drop for Apartment {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
// First eleven slots of the installed dual ILMXProxyServer interface. Slots
|
// First thirteen slots of the installed dual ILMXProxyServer interface. Slots
|
||||||
// 0–6 are IUnknown and IDispatch. The next four slots follow the installed
|
// 0–6 are IUnknown and IDispatch. The next six slots follow the installed
|
||||||
// interop assembly, with HRESULT and [out, retval] for the handle results.
|
// interop assembly, with HRESULT and [out, retval] for the handle results.
|
||||||
#[repr(C)]
|
#[repr(C)]
|
||||||
struct ProxyVtable {
|
struct ProxyVtable {
|
||||||
@@ -220,15 +226,19 @@ struct ProxyVtable {
|
|||||||
unregister: unsafe extern "system" fn(*mut c_void, i32) -> HRESULT,
|
unregister: unsafe extern "system" fn(*mut c_void, i32) -> HRESULT,
|
||||||
add_item: unsafe extern "system" fn(*mut c_void, i32, BSTR, *mut 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,
|
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 {
|
struct Proxy {
|
||||||
interface: NonNull<c_void>,
|
interface: NonNull<c_void>,
|
||||||
registrations: BTreeSet<i32>,
|
registrations: BTreeSet<i32>,
|
||||||
|
publisher: Publisher,
|
||||||
|
connection: Option<Connection>,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Proxy {
|
impl Proxy {
|
||||||
fn activate() -> Result<Self, HRESULT> {
|
fn activate(publisher: Publisher) -> Result<Self, HRESULT> {
|
||||||
let mut interface = null_mut();
|
let mut interface = null_mut();
|
||||||
// SAFETY: the output is for the exact IID declared by ProxyVtable.
|
// SAFETY: the output is for the exact IID declared by ProxyVtable.
|
||||||
check(unsafe {
|
check(unsafe {
|
||||||
@@ -240,10 +250,15 @@ impl Proxy {
|
|||||||
&mut interface,
|
&mut interface,
|
||||||
)
|
)
|
||||||
})?;
|
})?;
|
||||||
Ok(Self {
|
let mut proxy = Self {
|
||||||
interface: NonNull::new(interface).ok_or(0x8000_4003_u32 as i32)?,
|
interface: NonNull::new(interface).ok_or(0x8000_4003_u32 as i32)?,
|
||||||
registrations: BTreeSet::new(),
|
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 {
|
fn execute(&mut self, command: Command) -> Outcome {
|
||||||
@@ -265,6 +280,7 @@ impl Proxy {
|
|||||||
check(unsafe { (table.unregister)(object, server) })
|
check(unsafe { (table.unregister)(object, server) })
|
||||||
.map_err(CommandError::HResult)?;
|
.map_err(CommandError::HResult)?;
|
||||||
self.registrations.remove(&server);
|
self.registrations.remove(&server);
|
||||||
|
self.publisher.unregister(server);
|
||||||
Ok(None)
|
Ok(None)
|
||||||
}
|
}
|
||||||
Command::AddItem(server, definition) => {
|
Command::AddItem(server, definition) => {
|
||||||
@@ -279,6 +295,25 @@ impl Proxy {
|
|||||||
self.require_registration(server)?;
|
self.require_registration(server)?;
|
||||||
check(unsafe { (table.remove_item)(object, server, item) })
|
check(unsafe { (table.remove_item)(object, server, item) })
|
||||||
.map_err(CommandError::HResult)?;
|
.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)
|
Ok(None)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -293,7 +328,28 @@ impl Proxy {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn cleanup(&mut self) -> usize {
|
fn cleanup(&mut self) -> usize {
|
||||||
|
let advice = self.publisher.take_advice();
|
||||||
let mut failures = 0;
|
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) {
|
for server in std::mem::take(&mut self.registrations) {
|
||||||
// SAFETY: the interface is still live on this STA.
|
// SAFETY: the interface is still live on this STA.
|
||||||
let hr = unsafe { (self.vtable().unregister)(self.interface.as_ptr(), server) };
|
let hr = unsafe { (self.vtable().unregister)(self.interface.as_ptr(), server) };
|
||||||
@@ -316,6 +372,7 @@ impl Proxy {
|
|||||||
|
|
||||||
impl Drop for Proxy {
|
impl Drop for Proxy {
|
||||||
fn drop(&mut self) {
|
fn drop(&mut self) {
|
||||||
|
drop(self.connection.take());
|
||||||
// SAFETY: release the reference returned by CoCreateInstance on this STA.
|
// SAFETY: release the reference returned by CoCreateInstance on this STA.
|
||||||
unsafe { (self.vtable().release)(self.interface.as_ptr()) };
|
unsafe { (self.vtable().release)(self.interface.as_ptr()) };
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -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, ¶meters) }, S_OK);
|
||||||
|
assert_eq!(unsafe { sink.on_dispatch(1, ¶meters) }, 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, ¶meters) }, 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
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -2,23 +2,27 @@ use std::collections::HashMap;
|
|||||||
use std::io;
|
use std::io;
|
||||||
use std::time::{Duration, SystemTime};
|
use std::time::{Duration, SystemTime};
|
||||||
|
|
||||||
|
use prost::Message;
|
||||||
use prost_types::Timestamp;
|
use prost_types::Timestamp;
|
||||||
use tokio::io::{split, AsyncWrite};
|
use tokio::io::{split, AsyncWrite};
|
||||||
use tokio::net::windows::named_pipe::{ClientOptions, NamedPipeClient};
|
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 tokio::time::{interval, sleep, timeout, Instant, MissedTickBehavior};
|
||||||
|
|
||||||
|
use crate::automation::int32;
|
||||||
use crate::mxaccess::{Command, CommandError, Sta, StartError, CLASS_ID, PROG_ID};
|
use crate::mxaccess::{Command, CommandError, Sta, StartError, CLASS_ID, PROG_ID};
|
||||||
|
use crate::mxevent::{event_channel, EventFault, Publisher};
|
||||||
use crate::wire::{
|
use crate::wire::{
|
||||||
self,
|
self,
|
||||||
mxaccess_gateway::v1::{
|
mxaccess_gateway::v1::{
|
||||||
mx_command, mx_command_reply, mx_value, AddItemReply, DrainEventsReply, MxCommand,
|
mx_command, mx_command_reply, AddItemReply, DrainEventsReply, MxCommand, MxCommandKind,
|
||||||
MxCommandKind, MxCommandReply, MxDataType, MxValue, ProtocolStatus, ProtocolStatusCode,
|
MxCommandReply, MxEvent, ProtocolStatus, ProtocolStatusCode, RegisterReply, SessionState,
|
||||||
RegisterReply, SessionState, SessionStateReply, WorkerInfoReply,
|
SessionStateReply, WorkerInfoReply,
|
||||||
},
|
},
|
||||||
mxaccess_worker::v1::{
|
mxaccess_worker::v1::{
|
||||||
GatewayHello, WorkerCommand, WorkerCommandReply, WorkerFault, WorkerFaultCategory,
|
GatewayHello, WorkerCommand, WorkerCommandReply, WorkerEvent, WorkerFault,
|
||||||
WorkerHeartbeat, WorkerHello, WorkerReady, WorkerShutdownAck, WorkerState,
|
WorkerFaultCategory, WorkerHeartbeat, WorkerHello, WorkerReady, WorkerShutdownAck,
|
||||||
|
WorkerState,
|
||||||
},
|
},
|
||||||
Body, Writer, DEFAULT_MAX, VERSION,
|
Body, Writer, DEFAULT_MAX, VERSION,
|
||||||
};
|
};
|
||||||
@@ -65,6 +69,7 @@ struct Options {
|
|||||||
heartbeat_interval: Duration,
|
heartbeat_interval: Duration,
|
||||||
sta_grace: Duration,
|
sta_grace: Duration,
|
||||||
command_ceiling: Duration,
|
command_ceiling: Duration,
|
||||||
|
event_capacity: usize,
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Options {
|
impl Options {
|
||||||
@@ -112,6 +117,11 @@ impl Options {
|
|||||||
heartbeat_interval: env_duration("MXGATEWAY_WORKER_HEARTBEAT_SEND_INTERVAL_MS", 5000),
|
heartbeat_interval: env_duration("MXGATEWAY_WORKER_HEARTBEAT_SEND_INTERVAL_MS", 5000),
|
||||||
sta_grace: env_duration("MXGATEWAY_WORKER_HEARTBEAT_GRACE_MS", 15000),
|
sta_grace: env_duration("MXGATEWAY_WORKER_HEARTBEAT_GRACE_MS", 15000),
|
||||||
command_ceiling: env_duration("MXGATEWAY_WORKER_HEARTBEAT_STUCK_CEILING_MS", 75000),
|
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 {
|
let mut events = EventStream::new(&options);
|
||||||
Ok(sta) => sta,
|
let (sta, pin_status) = match Sta::start(events.publisher.clone()).await {
|
||||||
|
Ok(started) => started,
|
||||||
Err(error) => {
|
Err(error) => {
|
||||||
let (hresult, diagnostic) = match error {
|
let (hresult, diagnostic) = match error {
|
||||||
StartError::Io(error) => (None, error.to_string()),
|
StartError::Io(error) => (None, error.to_string()),
|
||||||
@@ -206,7 +217,7 @@ pub async fn run() -> Result<(), Error> {
|
|||||||
mxaccess_progid: PROG_ID.into(),
|
mxaccess_progid: PROG_ID.into(),
|
||||||
mxaccess_clsid: CLASS_ID.into(),
|
mxaccess_clsid: CLASS_ID.into(),
|
||||||
ready_timestamp: Some(now()),
|
ready_timestamp: Some(now()),
|
||||||
record_info_pin_status: String::new(),
|
record_info_pin_status: pin_status,
|
||||||
}),
|
}),
|
||||||
max,
|
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
|
// Keep the read half alive during graceful shutdown so the gateway can
|
||||||
// finish a control write before reading the ack.
|
// finish a control write before reading the ack.
|
||||||
let acknowledgement = match result {
|
let acknowledgement = match result {
|
||||||
@@ -299,11 +310,43 @@ async fn command_loop<W: AsyncWrite + Unpin>(
|
|||||||
sta: &Sta,
|
sta: &Sta,
|
||||||
writer: &mut Writer<W>,
|
writer: &mut Writer<W>,
|
||||||
frames: &mut mpsc::Receiver<io::Result<wire::WorkerEnvelope>>,
|
frames: &mut mpsc::Receiver<io::Result<wire::WorkerEnvelope>>,
|
||||||
|
events: &mut EventStream,
|
||||||
) -> Result<Duration, Error> {
|
) -> Result<Duration, Error> {
|
||||||
let mut heartbeat = interval(options.heartbeat_interval);
|
let mut heartbeat = interval(options.heartbeat_interval);
|
||||||
heartbeat.set_missed_tick_behavior(MissedTickBehavior::Delay);
|
heartbeat.set_missed_tick_behavior(MissedTickBehavior::Delay);
|
||||||
loop {
|
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! {
|
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() => {
|
frame = frames.recv() => {
|
||||||
let frame = frame.ok_or_else(|| Error(5, "Worker pipe reader exited".into()))??;
|
let frame = frame.ok_or_else(|| Error(5, "Worker pipe reader exited".into()))??;
|
||||||
let correlation = frame.correlation_id;
|
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 kind = command.as_ref().map_or(0, |command| command.kind);
|
||||||
let execution = timeout(
|
let execution = timeout(
|
||||||
options.command_ceiling,
|
options.command_ceiling,
|
||||||
execute(sta, command, &options.session, &correlation),
|
execute(sta, command, &options.session, &correlation, events, max),
|
||||||
).await;
|
).await;
|
||||||
let mut reply = match execution {
|
let mut reply = match execution {
|
||||||
Ok(Ok(reply)) => reply,
|
Ok(Ok(reply)) => reply,
|
||||||
@@ -364,6 +407,8 @@ async fn command_loop<W: AsyncWrite + Unpin>(
|
|||||||
worker_process_id: pid(),
|
worker_process_id: pid(),
|
||||||
state: WorkerState::Ready as i32,
|
state: WorkerState::Ready as i32,
|
||||||
last_sta_activity_timestamp: Some(now()),
|
last_sta_activity_timestamp: Some(now()),
|
||||||
|
outbound_event_queue_depth: events.depth() as u32,
|
||||||
|
last_event_sequence: events.publisher.last_sequence(),
|
||||||
..Default::default()
|
..Default::default()
|
||||||
}), max).await?;
|
}), max).await?;
|
||||||
}
|
}
|
||||||
@@ -376,6 +421,8 @@ async fn execute(
|
|||||||
command: Option<MxCommand>,
|
command: Option<MxCommand>,
|
||||||
session: &str,
|
session: &str,
|
||||||
correlation: &str,
|
correlation: &str,
|
||||||
|
events: &mut EventStream,
|
||||||
|
max: usize,
|
||||||
) -> Result<MxCommandReply, Error> {
|
) -> Result<MxCommandReply, Error> {
|
||||||
use mx_command::Payload;
|
use mx_command::Payload;
|
||||||
use mx_command_reply::Payload as Reply;
|
use mx_command_reply::Payload as Reply;
|
||||||
@@ -408,6 +455,12 @@ async fn execute(
|
|||||||
(Kind::RemoveItem, Some(Payload::RemoveItem(request))) => {
|
(Kind::RemoveItem, Some(Payload::RemoveItem(request))) => {
|
||||||
Command::RemoveItem(request.server_handle, request.item_handle)
|
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))) => {
|
(Kind::Ping, Some(Payload::Ping(request))) => {
|
||||||
reply.diagnostic_message = request.message;
|
reply.diagnostic_message = request.message;
|
||||||
return Ok(reply);
|
return Ok(reply);
|
||||||
@@ -429,8 +482,12 @@ async fn execute(
|
|||||||
}));
|
}));
|
||||||
return Ok(reply);
|
return Ok(reply);
|
||||||
}
|
}
|
||||||
(Kind::DrainEvents, None | Some(Payload::DrainEvents(_))) => {
|
(Kind::DrainEvents, payload @ (None | Some(Payload::DrainEvents(_)))) => {
|
||||||
reply.payload = Some(Reply::DrainEvents(DrainEventsReply::default()));
|
let requested = match payload {
|
||||||
|
Some(Payload::DrainEvents(request)) => request.max_events,
|
||||||
|
_ => 0,
|
||||||
|
};
|
||||||
|
reply.payload = Some(Reply::DrainEvents(events.drain(requested, max)));
|
||||||
return Ok(reply);
|
return Ok(reply);
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
@@ -444,12 +501,7 @@ async fn execute(
|
|||||||
};
|
};
|
||||||
match sta.execute(native).await.map_err(Error::sta)? {
|
match sta.execute(native).await.map_err(Error::sta)? {
|
||||||
Ok(Some(handle)) => {
|
Ok(Some(handle)) => {
|
||||||
reply.return_value = Some(MxValue {
|
reply.return_value = Some(int32(handle));
|
||||||
data_type: MxDataType::Integer as i32,
|
|
||||||
variant_type: "VT_I4".into(),
|
|
||||||
kind: Some(mx_value::Kind::Int32Value(handle)),
|
|
||||||
..Default::default()
|
|
||||||
});
|
|
||||||
reply.payload = Some(match kind {
|
reply.payload = Some(match kind {
|
||||||
Kind::Register => Reply::Register(RegisterReply {
|
Kind::Register => Reply::Register(RegisterReply {
|
||||||
server_handle: handle,
|
server_handle: handle,
|
||||||
@@ -477,6 +529,71 @@ async fn execute(
|
|||||||
Ok(reply)
|
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 {
|
fn command_reply(session: &str, correlation: &str, kind: i32) -> MxCommandReply {
|
||||||
MxCommandReply {
|
MxCommandReply {
|
||||||
session_id: session.into(),
|
session_id: session.into(),
|
||||||
|
|||||||
@@ -9,13 +9,13 @@ use tokio::io::{split, AsyncRead, AsyncWrite};
|
|||||||
use tokio::net::windows::named_pipe::ServerOptions;
|
use tokio::net::windows::named_pipe::ServerOptions;
|
||||||
use tokio::time::{sleep, timeout};
|
use tokio::time::{sleep, timeout};
|
||||||
use wire::mxaccess_gateway::v1::{
|
use wire::mxaccess_gateway::v1::{
|
||||||
mx_command, mx_command_reply, AddItemCommand, MxCommand, MxCommandKind, MxCommandReply,
|
mx_command, mx_command_reply, AddItemCommand, AdviseCommand, MxCommand, MxCommandKind,
|
||||||
ProtocolStatusCode, RegisterCommand, RemoveItemCommand, UnregisterCommand,
|
MxCommandReply, ProtocolStatusCode, RegisterCommand, RemoveItemCommand, UnregisterCommand,
|
||||||
};
|
};
|
||||||
use wire::mxaccess_worker::v1::{GatewayHello, WorkerCommand, WorkerShutdown};
|
use wire::mxaccess_worker::v1::{GatewayHello, WorkerCommand, WorkerShutdown};
|
||||||
use wire::{Body, Writer, DEFAULT_MAX, VERSION};
|
use wire::{Body, Writer, DEFAULT_MAX, VERSION};
|
||||||
|
|
||||||
const DEADLINE: Duration = Duration::from_secs(20);
|
const DEADLINE: Duration = Duration::from_secs(40);
|
||||||
|
|
||||||
#[tokio::test]
|
#[tokio::test]
|
||||||
#[ignore = "requires a registered 32-bit System Platform MXAccess installation"]
|
#[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;
|
.await;
|
||||||
|
|
||||||
// Leave a registration active to exercise the worker's shutdown cleanup.
|
// Leave a registration and, when a live item is configured, an advice
|
||||||
invoke(
|
// active to check that the shutdown acknowledgement is sent after cleanup.
|
||||||
|
let cleanup_registration = invoke(
|
||||||
&mut reader,
|
&mut reader,
|
||||||
&mut writer,
|
&mut writer,
|
||||||
session,
|
session,
|
||||||
@@ -153,6 +154,40 @@ async fn activates_registers_and_shuts_down_over_a_windows_pipe() {
|
|||||||
}),
|
}),
|
||||||
)
|
)
|
||||||
.await;
|
.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
|
writer
|
||||||
.send(
|
.send(
|
||||||
session,
|
session,
|
||||||
@@ -164,7 +199,7 @@ async fn activates_registers_and_shuts_down_over_a_windows_pipe() {
|
|||||||
.unwrap();
|
.unwrap();
|
||||||
loop {
|
loop {
|
||||||
match read_body(&mut reader, session).await {
|
match read_body(&mut reader, session).await {
|
||||||
Body::WorkerHeartbeat(_) => {}
|
Body::WorkerHeartbeat(_) | Body::WorkerEvent(_) => {}
|
||||||
Body::WorkerShutdownAck(ack) => {
|
Body::WorkerShutdownAck(ack) => {
|
||||||
let status = ack.status.unwrap();
|
let status = ack.status.unwrap();
|
||||||
assert_eq!(status.code(), ProtocolStatusCode::Ok);
|
assert_eq!(status.code(), ProtocolStatusCode::Ok);
|
||||||
|
|||||||
Reference in New Issue
Block a user