Complete Rust worker command coverage and bridge the alarm provider

This commit is contained in:
Joseph Doherty
2026-11-21 09:34:41 -05:00
parent d1769f81ff
commit dbc5ea0c25
12 changed files with 1945 additions and 160 deletions
@@ -475,6 +475,269 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output)
} }
} }
/// <summary>Exercises bulk operations and both snapshot read paths over gRPC.</summary>
/// <returns>A task that represents the live test.</returns>
[RustWorkerLiveFact]
public async Task GatewayGrpc_WithRustWorker_BulkItemsAndReads()
{
const string first = "TestMachine_001.TestChangingInt";
const string second = "TestMachine_002.TestChangingInt";
string workerPath = IntegrationTestEnvironment.ResolveLiveMxAccessWorkerExecutablePath();
await using GatewayServiceFixture fixture = new(workerPath, new TestWorkerProcessFactory(output), output);
await using WebApplication app = BuildLoopbackGateway(fixture.Service);
using CancellationTokenSource deadline = new(TimeSpan.FromSeconds(60));
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-bulk-items",
}, cancellationToken: token).ResponseAsync.ConfigureAwait(false);
Assert.Equal(ProtocolStatusCode.Ok, opened.ProtocolStatus.Code);
string id = opened.SessionId;
try
{
async Task<MxCommandReply> InvokeAsync(MxCommand command)
{
MxCommandReply reply = await client.InvokeAsync(new MxCommandRequest
{
SessionId = id, ClientCorrelationId = Guid.NewGuid().ToString("N"), Command = command,
}, cancellationToken: token).ResponseAsync.ConfigureAwait(false);
Assert.Equal(ProtocolStatusCode.Ok, reply.ProtocolStatus.Code);
return reply;
}
int server = (await InvokeAsync(CreateRegisterRequest(id).Command).ConfigureAwait(false)).Register.ServerHandle;
MxCommandReply extended = await InvokeAsync(new MxCommand
{
Kind = MxCommandKind.AddItem2,
AddItem2 = new AddItem2Command { ServerHandle = server, ItemDefinition = "TestChangingInt", ItemContext = "TestMachine_003" },
}).ConfigureAwait(false);
Assert.True(extended.AddItem2.ItemHandle > 0);
MxCommandReply subscribed = await InvokeAsync(new MxCommand
{
Kind = MxCommandKind.SubscribeBulk,
SubscribeBulk = new SubscribeBulkCommand { ServerHandle = server, TagAddresses = { first } },
}).ConfigureAwait(false);
SubscribeResult subscription = Assert.Single(subscribed.SubscribeBulk.Results);
Assert.True(subscription.WasSuccessful, subscription.ErrorMessage);
// Observe the permanent advice before checking the worker's value cache.
using (AsyncServerStreamingCall<MxEvent> events = client.StreamEvents(
new StreamEventsRequest { SessionId = id, EmitStreamAttached = true },
cancellationToken: token))
{
while (await events.ResponseStream.MoveNext(token).ConfigureAwait(false))
{
MxEvent change = events.ResponseStream.Current;
if (change.Family == MxEventFamily.OnDataChange && change.ItemHandle == subscription.ItemHandle)
{
break;
}
}
}
MxCommandReply read = await InvokeAsync(new MxCommand
{
Kind = MxCommandKind.ReadBulk,
ReadBulk = new ReadBulkCommand { ServerHandle = server, TimeoutMs = 3000, TagAddresses = { first, second, second } },
}).ConfigureAwait(false);
Assert.Collection(read.ReadBulk.Results,
cached => { Assert.True(cached.WasSuccessful, cached.ErrorMessage); Assert.True(cached.WasCached); },
snapshot => { Assert.True(snapshot.WasSuccessful, snapshot.ErrorMessage); Assert.False(snapshot.WasCached); },
duplicate =>
{
Assert.True(duplicate.WasSuccessful, duplicate.ErrorMessage);
Assert.False(duplicate.WasCached);
Assert.Equal(read.ReadBulk.Results[1].ItemHandle, duplicate.ItemHandle);
});
MxCommandReply added = await InvokeAsync(new MxCommand
{
Kind = MxCommandKind.AddItemBulk,
AddItemBulk = new AddItemBulkCommand { ServerHandle = server, TagAddresses = { second } },
}).ConfigureAwait(false);
SubscribeResult item = Assert.Single(added.AddItemBulk.Results);
Assert.True(item.WasSuccessful, item.ErrorMessage);
MxCommandReply advised = await InvokeAsync(new MxCommand
{
Kind = MxCommandKind.AdviseItemBulk,
AdviseItemBulk = new AdviseItemBulkCommand { ServerHandle = server, ItemHandles = { item.ItemHandle } },
}).ConfigureAwait(false);
Assert.True(Assert.Single(advised.AdviseItemBulk.Results).WasSuccessful);
MxCommandReply unadvised = await InvokeAsync(new MxCommand
{
Kind = MxCommandKind.UnAdviseItemBulk,
UnAdviseItemBulk = new UnAdviseItemBulkCommand { ServerHandle = server, ItemHandles = { item.ItemHandle } },
}).ConfigureAwait(false);
Assert.True(Assert.Single(unadvised.UnAdviseItemBulk.Results).WasSuccessful);
MxCommandReply removed = await InvokeAsync(new MxCommand
{
Kind = MxCommandKind.RemoveItemBulk,
RemoveItemBulk = new RemoveItemBulkCommand { ServerHandle = server, ItemHandles = { item.ItemHandle, extended.AddItem2.ItemHandle } },
}).ConfigureAwait(false);
Assert.All(removed.RemoveItemBulk.Results, result => Assert.True(result.WasSuccessful, result.ErrorMessage));
MxCommandReply unsubscribed = await InvokeAsync(new MxCommand
{
Kind = MxCommandKind.UnsubscribeBulk,
UnsubscribeBulk = new UnsubscribeBulkCommand { ServerHandle = server, ItemHandles = { subscription.ItemHandle } },
}).ConfigureAwait(false);
Assert.True(Assert.Single(unsubscribed.UnsubscribeBulk.Results).WasSuccessful);
output.WriteLine("Bulk add, advise, cached and snapshot reads, unadvise, remove, subscribe, and unsubscribe passed.");
}
finally
{
Assert.Equal(ProtocolStatusCode.Ok, (await client.CloseSessionAsync(new CloseSessionRequest
{
SessionId = id,
}, deadline: DateTime.UtcNow.AddSeconds(25)).ResponseAsync.ConfigureAwait(false)).ProtocolStatus.Code);
}
}
/// <summary>Verifies managed alarm provider callbacks forwarded by the Rust worker.</summary>
/// <returns>A task that represents the live test.</returns>
[RustWorkerLiveFact]
public async Task GatewayGrpc_WithRustWorker_ForwardsAlarmProviderCommandsAndEvents()
{
const string reference = "Galaxy!DEV.TestMachine_001.RustWorkerSmoke";
string workerPath = IntegrationTestEnvironment.ResolveLiveMxAccessWorkerExecutablePath();
await using GatewayServiceFixture fixture = new(workerPath, new TestWorkerProcessFactory(output), output);
await using WebApplication app = BuildLoopbackGateway(fixture.Service);
using CancellationTokenSource deadline = new(TimeSpan.FromSeconds(75));
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-alarms",
}, cancellationToken: token).ResponseAsync.ConfigureAwait(false);
Assert.Equal(ProtocolStatusCode.Ok, opened.ProtocolStatus.Code);
string id = opened.SessionId;
try
{
async Task<MxCommandReply> AlarmAsync(MxCommand command)
{
WorkerCommandReply envelope = await fixture.Manager.InvokeAsync(id,
new WorkerCommand { Command = command }, token).ConfigureAwait(false);
Assert.Equal(command.Kind, envelope.Reply.Kind);
return envelope.Reply;
}
using AsyncServerStreamingCall<MxEvent> events = client.StreamEvents(
new StreamEventsRequest { SessionId = id, EmitStreamAttached = true }, cancellationToken: token);
Assert.True(await events.ResponseStream.MoveNext(token).ConfigureAwait(false));
Assert.NotNull(events.ResponseStream.Current.StreamAttached);
MxCommandReply subscribed = await AlarmAsync(new MxCommand
{
Kind = MxCommandKind.SubscribeAlarms,
SubscribeAlarms = new SubscribeAlarmsCommand
{
SubscriptionExpression = $@"\\{Environment.MachineName}\Galaxy!DEV",
ForcedMode = AlarmProviderMode.Subtag,
WatchList = { new AlarmSubtagTarget
{
AlarmFullReference = reference, SourceObjectReference = "TestMachine_001",
ActiveSubtag = "TestMachine_001.TestChangingInt",
} },
},
}).ConfigureAwait(false);
Assert.True(subscribed.ProtocolStatus.Code == ProtocolStatusCode.Ok, subscribed.DiagnosticMessage);
MxEvent? transition = null;
while (await events.ResponseStream.MoveNext(token).ConfigureAwait(false))
{
if (events.ResponseStream.Current.OnAlarmTransition?.AlarmFullReference == reference)
{
transition = events.ResponseStream.Current;
break;
}
}
Assert.NotNull(transition);
Assert.Equal(id, transition.SessionId);
Assert.True(transition.WorkerSequence > 0);
Assert.True(transition.OnAlarmTransition.Degraded);
output.WriteLine($"Forwarded {transition.OnAlarmTransition.TransitionKind} at worker sequence {transition.WorkerSequence}.");
MxCommandReply snapshot = await AlarmAsync(new MxCommand
{
Kind = MxCommandKind.QueryActiveAlarms,
QueryActiveAlarmsCommand = new QueryActiveAlarmsCommand { AlarmFilterPrefix = reference },
}).ConfigureAwait(false);
Assert.Equal(ProtocolStatusCode.Ok, snapshot.ProtocolStatus.Code);
Assert.Contains(snapshot.QueryActiveAlarms.Snapshots, alarm => alarm.AlarmFullReference == reference);
MxCommandReply unknownAck = await AlarmAsync(new MxCommand
{
Kind = MxCommandKind.AcknowledgeAlarm,
AcknowledgeAlarmCommand = new AcknowledgeAlarmCommand { AlarmGuid = Guid.NewGuid().ToString() },
}).ConfigureAwait(false);
Assert.NotNull(unknownAck.AcknowledgeAlarm);
Assert.NotEqual(0, unknownAck.AcknowledgeAlarm.NativeStatus);
MxCommandReply unknownName = await AlarmAsync(new MxCommand
{
Kind = MxCommandKind.AcknowledgeAlarmByName,
AcknowledgeAlarmByNameCommand = new AcknowledgeAlarmByNameCommand
{
AlarmName = "RustWorkerMissingAlarm", ProviderName = "Galaxy", GroupName = "DEV",
},
}).ConfigureAwait(false);
Assert.NotNull(unknownName.AcknowledgeAlarm);
Assert.NotEqual(0, unknownName.AcknowledgeAlarm.NativeStatus);
MxCommandReply update = await AlarmAsync(new MxCommand
{
Kind = MxCommandKind.UpdateAlarmWatchList,
UpdateAlarmWatchList = new UpdateAlarmWatchListCommand(),
}).ConfigureAwait(false);
Assert.Equal(ProtocolStatusCode.MxaccessFailure, update.ProtocolStatus.Code);
MxCommandReply unsubscribed = await AlarmAsync(new MxCommand
{
Kind = MxCommandKind.UnsubscribeAlarms,
UnsubscribeAlarms = new UnsubscribeAlarmsCommand(),
}).ConfigureAwait(false);
Assert.Equal(ProtocolStatusCode.Ok, unsubscribed.ProtocolStatus.Code);
MxCommandReply fallback = await AlarmAsync(new MxCommand
{
Kind = MxCommandKind.SubscribeAlarms,
SubscribeAlarms = new SubscribeAlarmsCommand
{
SubscriptionExpression = $@"\\{Environment.MachineName}\Galaxy!DEV",
FallbackEnabled = true,
Failover = new AlarmFailoverConfig
{
ConsecutiveFailureThreshold = 1, FailbackProbeIntervalSeconds = 30, FailbackStableProbes = 3,
},
},
}).ConfigureAwait(false);
Assert.True(fallback.ProtocolStatus.Code == ProtocolStatusCode.Ok, fallback.DiagnosticMessage);
MxCommandReply replacement = await AlarmAsync(new MxCommand
{
Kind = MxCommandKind.UpdateAlarmWatchList,
UpdateAlarmWatchList = new UpdateAlarmWatchListCommand
{
WatchList = { new AlarmSubtagTarget
{
AlarmFullReference = reference, SourceObjectReference = "TestMachine_001",
ActiveSubtag = "TestMachine_001.TestChangingInt",
} },
},
}).ConfigureAwait(false);
Assert.True(replacement.ProtocolStatus.Code == ProtocolStatusCode.Ok, replacement.DiagnosticMessage);
output.WriteLine("Updated the live alarm provider's fallback watch list.");
}
finally
{
Assert.Equal(ProtocolStatusCode.Ok, (await client.CloseSessionAsync(new CloseSessionRequest
{
SessionId = id,
}, deadline: DateTime.UtcNow.AddSeconds(25)).ResponseAsync.ConfigureAwait(false)).ProtocolStatus.Code);
}
}
private static WebApplication BuildLoopbackGateway(MxAccessGatewayService service) private static WebApplication BuildLoopbackGateway(MxAccessGatewayService service)
{ {
WebApplicationBuilder builder = WebApplication.CreateSlimBuilder(); WebApplicationBuilder builder = WebApplication.CreateSlimBuilder();
@@ -2492,6 +2755,7 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output)
options, options,
_metrics, _metrics,
logger: _loggerFactory.CreateLogger<SessionManager>()); logger: _loggerFactory.CreateLogger<SessionManager>());
Manager = sessionManager;
MxAccessGrpcMapper mapper = new(); MxAccessGrpcMapper mapper = new();
EventStreamService eventStreamService = new( EventStreamService eventStreamService = new(
sessionManager, sessionManager,
@@ -2520,6 +2784,9 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output)
/// </summary> /// </summary>
public MxAccessGatewayService Service { get; } public MxAccessGatewayService Service { get; }
/// <summary>The manager used by the gateway's internal alarm monitor.</summary>
public SessionManager Manager { get; }
/// <summary> /// <summary>
/// Looks up a session by id directly against the in-process registry. The abnormal /// Looks up a session by id directly against the in-process registry. The abnormal
/// worker-exit test needs to observe the session's State / FinalFault as the gateway /// worker-exit test needs to observe the session's State / FinalFault as the gateway
+11
View File
@@ -313,6 +313,16 @@ dependencies = [
"windows-sys", "windows-sys",
] ]
[[package]]
name = "signal-hook-registry"
version = "1.4.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
dependencies = [
"errno",
"libc",
]
[[package]] [[package]]
name = "socket2" name = "socket2"
version = "0.6.5" version = "0.6.5"
@@ -368,6 +378,7 @@ dependencies = [
"libc", "libc",
"mio", "mio",
"pin-project-lite", "pin-project-lite",
"signal-hook-registry",
"socket2", "socket2",
"tokio-macros", "tokio-macros",
"windows-sys", "windows-sys",
+4 -1
View File
@@ -10,13 +10,16 @@ prost-types = "0.13.5"
tokio = { version = "1.48", features = ["io-util"] } tokio = { version = "1.48", features = ["io-util"] }
[target.'cfg(windows)'.dependencies] [target.'cfg(windows)'.dependencies]
tokio = { version = "1.48", features = ["macros", "net", "rt", "sync", "time"] } tokio = { version = "1.48", features = ["macros", "net", "process", "rt", "sync", "time"] }
windows-sys = { version = "0.61", features = [ windows-sys = { version = "0.61", features = [
"Win32_Foundation", "Win32_Foundation",
"Win32_Globalization", "Win32_Globalization",
"Win32_Security", "Win32_Security",
"Win32_Security_Cryptography",
"Win32_System_Com", "Win32_System_Com",
"Win32_System_JobObjects",
"Win32_System_Ole", "Win32_System_Ole",
"Win32_System_Pipes",
"Win32_System_Threading", "Win32_System_Threading",
"Win32_System_Time", "Win32_System_Time",
"Win32_System_Variant", "Win32_System_Variant",
+44 -7
View File
@@ -6,9 +6,10 @@ 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, Advise, It supports registration, item lifecycle and advice, value snapshots, identity
AdviseSupervisory, UnAdvise, and the worker diagnostic commands. The worker uses the base MXAccess COM connection lookup, writes, and the worker diagnostic commands. The worker attaches to
point for OnDataChange, OperationComplete, and OnWriteComplete notifications. both MXAccess COM connection points to deliver OnDataChange, OperationComplete,
OnWriteComplete, and OnBufferedDataChange notifications.
OnDataChange carries the value, quality, MXAccess status records, source OnDataChange carries the value, quality, MXAccess status records, source
timestamp when available, and worker sequence and timestamp. The bounded queue timestamp when available, and worker sequence and timestamp. The bounded queue
faults the session on overflow. Shutdown detaches the sink, unadvises remaining faults the session on overflow. Shutdown detaches the sink, unadvises remaining
@@ -17,10 +18,15 @@ gateway default.
Event conversion supports standard Automation scalar values and homogeneous Event conversion supports standard Automation scalar values and homogeneous
arrays of those types. Other variant types are reported as unknown with the arrays of those types. Other variant types are reported as unknown with the
Automation type in the diagnostic. The worker serializes commands and faults Automation type in the diagnostic. The worker serializes COM commands, accepts
the session if a COM call exceeds the STA timeout. Buffered advice, bulk cancellation for commands still waiting, and continues sending events and
subscriptions, snapshot reads, and alarm commands are outside the current heartbeats while a command runs. A COM call that exceeds the STA ceiling faults
implementation. the session.
Bulk item operations return one ordered result per requested item. ReadBulk
uses a cached value for an existing advice when available and otherwise uses
temporary advice with a shared timeout. Duplicate snapshot reads share one
subscription.
The worker supports Write, Write2, WriteSecured, and WriteSecured2, including The worker supports Write, Write2, WriteSecured, and WriteSecured2, including
their bulk forms. It converts scalar and typed array inputs to Automation their bulk forms. It converts scalar and typed array inputs to Automation
@@ -32,6 +38,27 @@ by MXAccess. The event also flows through StreamEvents. Bulk results report
per-item COM acceptance and clients can observe commit outcomes on the event per-item COM acceptance and clients can observe commit outcomes on the event
stream. stream.
## Managed alarm provider
The Rust process owns the gateway session, native data operations, and event
sequencing. Alarm commands run in the existing x86 .NET Framework worker, which
owns the WnWrap alarm manager, subtag fallback, watch-list replacement, alarm
snapshots, and acknowledgement. The managed process starts on the first alarm
command. It connects to a private local pipe whose client PID and launch nonce
are checked. A Windows job ties the managed process to the Rust worker's
lifetime.
Build the C# worker with the matching repository revision and deliver its
entire output directory under `alarm-worker` beside the Rust executable. Keep
the managed executable named `ZB.MOM.WW.MxGateway.Worker.exe`, or set
`MXGATEWAY_RUST_ALARM_WORKER_EXE` to its absolute path in the gateway process
environment.
```powershell
dotnet build src/ZB.MOM.WW.MxGateway.Worker -c Release -p:Platform=x86
```
## Build and test ## Build and test
From this directory on Windows, with Rust, the x86 MSVC target and linker, and From this directory on Windows, with Rust, the x86 MSVC target and linker, and
@@ -82,6 +109,14 @@ $env:MXGATEWAY_LIVE_MXACCESS_ITEM = 'TestChildObject.TestInt'
dotnet test src/ZB.MOM.WW.MxGateway.IntegrationTests --filter FullyQualifiedName~GatewayGrpc_WithRustWorker_WritesAndReceivesOnWriteComplete dotnet test src/ZB.MOM.WW.MxGateway.IntegrationTests --filter FullyQualifiedName~GatewayGrpc_WithRustWorker_WritesAndReceivesOnWriteComplete
``` ```
The remaining parity smoke tests use the deployed `TestChangingInt` items
for bulk snapshots and a read-only, synthetic subtag alarm. Set the absolute
managed worker path before running the alarm test.
```powershell
dotnet test src/ZB.MOM.WW.MxGateway.IntegrationTests --filter 'FullyQualifiedName~GatewayGrpc_WithRustWorker_BulkItemsAndReads|FullyQualifiedName~GatewayGrpc_WithRustWorker_ForwardsAlarmProviderCommandsAndEvents'
```
## 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
@@ -100,3 +135,5 @@ the corresponding native calls and event callbacks.
`ev_97162abcd831b2d84b5b43fb72cd9876252bbe3bb0af5c4673a6954911500e54` `ev_97162abcd831b2d84b5b43fb72cd9876252bbe3bb0af5c4673a6954911500e54`
- REA write member evidence for `ILMXProxyServer` and `ILMXProxyServer4` - REA write member evidence for `ILMXProxyServer` and `ILMXProxyServer4`
`ev_1b4fe7ab436437391b76f9fa3a300f45b58a4e1cff6aa84e30854f653c0a20df` `ev_1b4fe7ab436437391b76f9fa3a300f45b58a4e1cff6aa84e30854f653c0a20df`
- REA extended COM and buffered event member evidence
`ev_39de39d626e3a933b259fa2650b42311ba60d6844d7b012284467284e8b82977`
+340
View File
@@ -0,0 +1,340 @@
//! The existing managed alarm provider owns WnWrap, fallback subscriptions, and
//! acknowledgement. This bridge carries its alarm RPCs and callbacks over the
//! worker protocol while the Rust process owns the gateway session and sequencing.
use std::io;
use std::mem::size_of;
use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};
use std::path::PathBuf;
use std::ptr::{null, null_mut};
use std::sync::{
atomic::{AtomicBool, Ordering},
Arc,
};
use std::time::Duration;
use tokio::io::{split, WriteHalf};
use tokio::net::windows::named_pipe::{NamedPipeServer, ServerOptions};
use tokio::process::{Child, Command};
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
use tokio::time::timeout;
use windows_sys::Win32::Security::Cryptography::{
BCryptGenRandom, BCRYPT_USE_SYSTEM_PREFERRED_RNG,
};
use windows_sys::Win32::System::JobObjects::{
AssignProcessToJobObject, CreateJobObjectW, JobObjectExtendedLimitInformation,
SetInformationJobObject, JOBOBJECT_EXTENDED_LIMIT_INFORMATION,
JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
};
use windows_sys::Win32::System::Pipes::GetNamedPipeClientProcessId;
use crate::mxevent::{EventFault, Publisher};
use crate::wire::{
self,
mxaccess_gateway::v1::{
MxCommand, MxCommandKind, MxCommandReply, MxEventFamily, ProtocolStatusCode,
},
mxaccess_worker::v1::{GatewayHello, WorkerCommand, WorkerShutdown},
Body, WorkerEnvelope, Writer, DEFAULT_MAX, VERSION,
};
const ALARM_WORKER_ENV: &str = "MXGATEWAY_RUST_ALARM_WORKER_EXE";
pub fn handles(kind: MxCommandKind) -> bool {
matches!(
kind,
MxCommandKind::SubscribeAlarms
| MxCommandKind::UnsubscribeAlarms
| MxCommandKind::UpdateAlarmWatchList
| MxCommandKind::QueryActiveAlarms
| MxCommandKind::AcknowledgeAlarm
| MxCommandKind::AcknowledgeAlarmByName
)
}
pub struct AlarmWorker {
child: Child,
_job: OwnedHandle,
writer: Writer<WriteHalf<NamedPipeServer>>,
replies: mpsc::Receiver<WorkerEnvelope>,
reader: JoinHandle<()>,
shutting_down: Arc<AtomicBool>,
}
impl AlarmWorker {
pub async fn start(session: &str, max: usize, publisher: Publisher) -> io::Result<Self> {
let executable = alarm_executable()?;
let pipe_name = format!("mxgw-rust-alarm-{}", random_token()?);
let nonce = random_token()?;
let pipe = ServerOptions::new()
.first_pipe_instance(true)
.reject_remote_clients(true)
.create(format!(r"\\.\pipe\{pipe_name}"))?;
let job = kill_on_close_job()?;
let mut command = Command::new(&executable);
if let Some(directory) = executable.parent() {
command.current_dir(directory);
}
let child = command
.args([
"--session-id",
session,
"--pipe-name",
&pipe_name,
"--protocol-version",
"1",
])
.env("MXGATEWAY_WORKER_NONCE", &nonce)
.kill_on_drop(true)
.spawn()?;
let pid = child.id().ok_or_else(disconnected)?;
let child_handle = child.raw_handle().ok_or_else(disconnected)?;
// SAFETY: both handles remain live and the new job is owned by this worker.
if unsafe { AssignProcessToJobObject(job.as_raw_handle(), child_handle) } == 0 {
return Err(io::Error::last_os_error());
}
let (mut reader, writer) = timeout(Duration::from_secs(15), async {
pipe.connect().await?;
let mut connected_pid = 0;
if unsafe { GetNamedPipeClientProcessId(pipe.as_raw_handle(), &mut connected_pid) } == 0
{
return Err(io::Error::last_os_error());
}
if connected_pid != pid {
return Err(invalid(
"Unexpected process connected to the alarm worker pipe",
));
}
let (mut reader, writer) = split(pipe);
let mut writer = Writer::new(writer);
writer
.send(
session,
"",
Body::GatewayHello(GatewayHello {
supported_protocol_version: VERSION,
nonce: nonce.clone(),
max_frame_bytes: max as u32,
gateway_version: env!("CARGO_PKG_VERSION").into(),
}),
DEFAULT_MAX,
)
.await?;
let hello = wire::read(&mut reader, session, DEFAULT_MAX).await?;
match hello.body {
Some(Body::WorkerHello(hello))
if hello.protocol_version == VERSION
&& hello.worker_process_id == pid as i32
&& hello.nonce == nonce => {}
_ => return Err(invalid("Alarm worker handshake failed")),
}
let ready = wire::read(&mut reader, session, max).await?;
match ready.body {
Some(Body::WorkerReady(ready)) if ready.worker_process_id == pid as i32 => {
Ok((reader, writer))
}
_ => Err(invalid("Managed alarm worker failed to initialize")),
}
})
.await
.map_err(|_| io::Error::new(io::ErrorKind::TimedOut, "Alarm worker startup timed out"))??;
let (incoming, replies) = mpsc::channel(1);
let reader_session = session.to_owned();
let shutting_down = Arc::new(AtomicBool::new(false));
let closing = Arc::clone(&shutting_down);
let reader = tokio::spawn(async move {
while let Ok(frame) = wire::read(&mut reader, &reader_session, max).await {
match frame.body.as_ref() {
Some(Body::WorkerEvent(event)) => {
if let Some(event) = event.event.as_ref() {
if matches!(
event.family(),
MxEventFamily::OnAlarmTransition
| MxEventFamily::OnAlarmProviderModeChanged
) {
publisher.publish(event.clone());
}
}
}
Some(Body::WorkerHeartbeat(_)) => {}
Some(Body::WorkerCommandReply(_) | Body::WorkerShutdownAck(_)) => {
if incoming.send(frame).await.is_err() {
break;
}
}
_ => break,
}
}
if !closing.load(Ordering::Acquire) {
publisher.report_fault(EventFault::AlarmDisconnected);
}
});
Ok(Self {
child,
_job: job,
writer,
replies,
reader,
shutting_down,
})
}
pub async fn invoke(
&mut self,
session: &str,
max: usize,
correlation: &str,
command: MxCommand,
) -> io::Result<MxCommandReply> {
let kind = command.kind;
self.writer
.send(
session,
correlation,
Body::WorkerCommand(WorkerCommand {
command: Some(command),
enqueue_timestamp: Some(std::time::SystemTime::now().into()),
}),
max,
)
.await?;
let frame = self.replies.recv().await.ok_or_else(disconnected)?;
match frame.body {
Some(Body::WorkerCommandReply(response)) if frame.correlation_id == correlation => {
response
.reply
.filter(|reply| {
reply.session_id == session
&& reply.correlation_id == correlation
&& reply.kind == kind
})
.ok_or_else(|| invalid("Alarm worker reply did not match the request"))
}
_ => Err(invalid("Alarm worker sent an unexpected response")),
}
}
pub async fn shutdown(
mut self,
session: &str,
max: usize,
grace: Duration,
) -> io::Result<usize> {
self.shutting_down.store(true, Ordering::Release);
self.writer
.send(
session,
"",
Body::WorkerShutdown(WorkerShutdown {
grace_period: prost_types::Duration::try_from(grace).ok(),
reason: String::new(),
}),
max,
)
.await?;
let mut failures = match self.replies.recv().await.and_then(|frame| frame.body) {
Some(Body::WorkerShutdownAck(ack))
if ack
.status
.as_ref()
.is_some_and(|status| status.code() == ProtocolStatusCode::Ok) =>
{
0
}
_ => 1,
};
if !self.child.wait().await?.success() {
failures += 1;
}
Ok(failures)
}
}
impl Drop for AlarmWorker {
fn drop(&mut self) {
self.shutting_down.store(true, Ordering::Release);
self.reader.abort();
}
}
fn alarm_executable() -> io::Result<PathBuf> {
let current = std::env::current_exe()?.canonicalize()?;
let path = match std::env::var_os(ALARM_WORKER_ENV) {
Some(value) => {
let path = PathBuf::from(value);
if !path.is_absolute() {
return Err(invalid("Configured alarm worker path must be absolute"));
}
path
}
None => current
.with_file_name("alarm-worker")
.join("ZB.MOM.WW.MxGateway.Worker.exe"),
};
let path = path.canonicalize().map_err(|_| {
io::Error::new(
io::ErrorKind::NotFound,
"Managed alarm worker executable was not found",
)
})?;
if path == current || !path.is_file() {
return Err(invalid("Managed alarm worker path is invalid"));
}
Ok(path)
}
fn random_token() -> io::Result<String> {
let mut bytes = [0_u8; 24];
// SAFETY: BCrypt writes exactly the declared length to the local buffer.
if unsafe {
BCryptGenRandom(
null_mut(),
bytes.as_mut_ptr(),
bytes.len() as u32,
BCRYPT_USE_SYSTEM_PREFERRED_RNG,
)
} < 0
{
return Err(io::Error::other(
"Could not generate an alarm worker handshake token",
));
}
Ok(bytes.iter().map(|byte| format!("{byte:02x}")).collect())
}
fn kill_on_close_job() -> io::Result<OwnedHandle> {
// SAFETY: ownership of the unnamed job transfers to OwnedHandle.
let handle = unsafe { CreateJobObjectW(null(), null()) };
if handle.is_null() {
return Err(io::Error::last_os_error());
}
let handle = unsafe { OwnedHandle::from_raw_handle(handle) };
let mut limits = JOBOBJECT_EXTENDED_LIMIT_INFORMATION::default();
limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
if unsafe {
SetInformationJobObject(
handle.as_raw_handle(),
JobObjectExtendedLimitInformation,
(&limits as *const JOBOBJECT_EXTENDED_LIMIT_INFORMATION).cast(),
size_of::<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>() as u32,
)
} == 0
{
return Err(io::Error::last_os_error());
}
Ok(handle)
}
fn invalid(message: &'static str) -> io::Error {
io::Error::new(io::ErrorKind::InvalidData, message)
}
fn disconnected() -> io::Error {
io::Error::new(
io::ErrorKind::BrokenPipe,
"Managed alarm worker disconnected",
)
}
+152 -19
View File
@@ -660,13 +660,163 @@ fn file_time_timestamp(ticks: i64) -> Option<Timestamp> {
// Installed MXSTATUS_PROXY 3.2: 16 bytes with members at offsets 0, 4, 8, 12. // Installed MXSTATUS_PROXY 3.2: 16 bytes with members at offsets 0, 4, 8, 12.
#[repr(C)] #[repr(C)]
struct StatusRecord { #[derive(Default)]
pub struct StatusRecord {
success: i16, success: i16,
category: i32, category: i32,
source: i32, source: i32,
detail: i16, detail: i16,
} }
impl StatusRecord {
pub fn to_proto(&self) -> MxStatusProxy {
MxStatusProxy {
success: self.success.into(),
category: match self.category {
0..=8 => self.category + 2,
_ => MxStatusCategory::Unknown as i32,
},
detected_by: match self.source {
0..=5 => self.source + 2,
_ => MxStatusSource::Unknown as i32,
},
detail: self.detail.into(),
raw_category: self.category,
raw_detected_by: self.source,
diagnostic_text: status_detail(self.detail).into(),
}
}
}
// MXAccess completion detail codes, shared with the managed converter.
fn status_detail(detail: i16) -> &'static str {
match detail {
16 => "Request timed out",
17 => "Platform communication error",
18 => "Invalid platform ID",
19 => "Invalid engine ID",
20 => "Engine communication error",
21 => "Invalid reference",
22 => "No Galaxy Repository",
23 => "Invalid object ID",
24 => "Object signature mismatch",
25 => "Invalid primitive ID",
26 => "Invalid attribute ID",
27 => "Invalid property ID",
28 => "Index out of range",
29 => "Data out of range",
30 => "Incorrect data type",
31 => "Attribute not readable",
32 => "Attribute not writeable",
33 => "Write access denied",
34 => "Unknown error",
36 => "Wrong data type",
37 => "Wrong number of dimensions",
38 => "Invalid index",
39 => "Index out of order",
40 => "Dimension does not exist",
41 => "Conversion not supported",
42 => "Unable to convert string",
43 => "Overflow",
44 => "Attribute signature mismatch",
47 => "Nmx version mismatch",
48 => "Nmx command not valid",
49 => "Lmx version mismatch",
50 => "Lmx command not valid",
56 => "Secured Write",
57 => "Verified Write",
60 => "User did not have the necessary permissions to write",
61 => "Verifier did not have the necessary permissions to verify",
541 => "Conversion to intended data type is not supported",
542 => "Unable to convert the input string to intended data type",
8017 => "Object must be offscan to modify attributes that have an MxSecurityConfigure security classification",
_ => "",
}
}
pub fn native_data_type(raw: i32) -> i32 {
match raw {
0..=17 => raw + 2,
_ => MxDataType::Unknown as i32,
}
}
pub unsafe fn buffered_array(value: &VARIANT, expected: MxDataType) -> MxArray {
// Buffered timestamp arrays can carry signed 64-bit Windows FILETIME values.
let converted = unsafe { dispatch_value(value) };
let kind = converted.kind;
if let Some(Kind::ArrayValue(mut array)) = kind {
if expected == MxDataType::Time {
if let Some(Values::Int64Values(ticks)) = &array.values {
if let Some(timestamps) = ticks
.values
.iter()
.copied()
.map(file_time_timestamp)
.collect::<Option<Vec<_>>>()
{
array.element_data_type = expected as i32;
array.values = Some(Values::TimestampValues(TimestampArray {
values: timestamps,
}));
}
}
}
return array;
}
let values = match kind {
Some(Kind::BoolValue(value)) => Some(Values::BoolValues(BoolArray {
values: vec![value],
})),
Some(Kind::Int32Value(value)) => Some(Values::Int32Values(Int32Array {
values: vec![value],
})),
Some(Kind::Int64Value(value)) if expected == MxDataType::Time => file_time_timestamp(value)
.map(|value| {
Values::TimestampValues(TimestampArray {
values: vec![value],
})
}),
Some(Kind::Int64Value(value)) => Some(Values::Int64Values(Int64Array {
values: vec![value],
})),
Some(Kind::FloatValue(value)) => Some(Values::FloatValues(FloatArray {
values: vec![value],
})),
Some(Kind::DoubleValue(value)) => Some(Values::DoubleValues(DoubleArray {
values: vec![value],
})),
Some(Kind::StringValue(value)) => Some(Values::StringValues(StringArray {
values: vec![value],
})),
Some(Kind::TimestampValue(value)) => Some(Values::TimestampValues(TimestampArray {
values: vec![value],
})),
_ => None,
};
let element_data_type = if matches!(values, Some(Values::TimestampValues(_))) {
MxDataType::Time as i32
} else {
converted.data_type
};
MxArray {
element_data_type,
variant_type: converted.variant_type,
dimensions: if values.is_some() {
vec![1]
} else {
Vec::new()
},
raw_diagnostic: if converted.raw_diagnostic.is_empty() {
"Buffered MXAccess event argument was not a SAFEARRAY.".into()
} else {
converted.raw_diagnostic
},
values,
..Default::default()
}
}
pub unsafe fn dispatch_statuses(value: &VARIANT) -> Result<Vec<MxStatusProxy>, &'static str> { pub unsafe fn dispatch_statuses(value: &VARIANT) -> Result<Vec<MxStatusProxy>, &'static str> {
let value = unsafe { unwrap_variant(*value) }.ok_or("null status VARIANT")?; let value = unsafe { unwrap_variant(*value) }.ok_or("null status VARIANT")?;
let inner = unsafe { &value.Anonymous.Anonymous }; let inner = unsafe { &value.Anonymous.Anonymous };
@@ -706,24 +856,7 @@ unsafe fn read_status_records(array: *const SAFEARRAY) -> Result<Vec<MxStatusPro
} else { } else {
// SAFETY: the checked one-dimensional record array remains locked while copied. // SAFETY: the checked one-dimensional record array remains locked while copied.
let records = unsafe { slice::from_raw_parts(data.cast::<StatusRecord>(), count) }; let records = unsafe { slice::from_raw_parts(data.cast::<StatusRecord>(), count) };
Ok(records Ok(records.iter().map(StatusRecord::to_proto).collect())
.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) }; unsafe { SafeArrayUnaccessData(array) };
result result
+2
View File
@@ -1,6 +1,8 @@
#[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 alarm;
#[cfg(all(windows, target_arch = "x86"))] #[cfg(all(windows, target_arch = "x86"))]
mod automation; mod automation;
#[cfg(all(windows, target_arch = "x86"))] #[cfg(all(windows, target_arch = "x86"))]
+201 -19
View File
@@ -1,7 +1,11 @@
use crate::automation::{AutomationString, WriteValue, WriteValueError}; use crate::automation::{AutomationString, StatusRecord, WriteValue, WriteValueError};
use crate::mxevent::{ComReference, Connection, Publisher, RecordInfoPin, WriteCompletion}; use crate::mxevent::{ComReference, Connection, Publisher, RecordInfoPin, WriteCompletion};
use crate::wire::mxaccess_gateway::v1::{BulkWriteResult, MxValue}; use crate::wire::mxaccess_gateway::v1::{
use std::collections::BTreeSet; BulkReadResult, BulkWriteResult, MxStatusProxy, MxValue, SubscribeResult,
};
use std::collections::{BTreeMap, BTreeSet};
use std::time::Duration;
mod items;
use std::ffi::c_void; use std::ffi::c_void;
use std::io; use std::io;
use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle}; use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle};
@@ -10,7 +14,7 @@ use std::sync::{mpsc, Arc};
use std::thread; use std::thread;
use tokio::sync::oneshot; use tokio::sync::oneshot;
use windows_sys::core::{BSTR, GUID, HRESULT}; use windows_sys::core::{BSTR, GUID, HRESULT};
use windows_sys::Win32::Foundation::WAIT_OBJECT_0; use windows_sys::Win32::Foundation::{E_INVALIDARG, WAIT_OBJECT_0};
use windows_sys::Win32::System::Com::{ use windows_sys::Win32::System::Com::{
CoCreateInstance, CoInitializeEx, CoUninitialize, CLSCTX_INPROC_SERVER, CoCreateInstance, CoInitializeEx, CoUninitialize, CLSCTX_INPROC_SERVER,
COINIT_APARTMENTTHREADED, COINIT_APARTMENTTHREADED,
@@ -26,6 +30,9 @@ pub const PROG_ID: &str = "LMXProxy.LMXProxyServer.1";
pub const CLASS_ID: &str = "{C30B52F5-2CB5-4760-AF0A-3A344A7EB5DC}"; pub const CLASS_ID: &str = "{C30B52F5-2CB5-4760-AF0A-3A344A7EB5DC}";
const CLSID: GUID = GUID::from_u128(0xc30b52f5_2cb5_4760_af0a_3a344a7eb5dc); const CLSID: GUID = GUID::from_u128(0xc30b52f5_2cb5_4760_af0a_3a344a7eb5dc);
const IID: GUID = GUID::from_u128(0xcce67fb7_eafd_4367_9212_617043bf126d); const IID: GUID = GUID::from_u128(0xcce67fb7_eafd_4367_9212_617043bf126d);
const IID_V2: GUID = GUID::from_u128(0x020a8a87_69c5_497f_a893_b629e669fbff);
const IID_V3: GUID = GUID::from_u128(0x57d006b6_f25e_4654_a81e_bcbafd60fe59);
const IID_V5: GUID = GUID::from_u128(0xeceff506_a752_46e3_9e31_0a8e257c9926);
const IID_V4: GUID = GUID::from_u128(0x9dc0d5c1_9371_4e84_86f8_7091d316a66c); const IID_V4: GUID = GUID::from_u128(0x9dc0d5c1_9371_4e84_86f8_7091d316a66c);
pub enum Command { pub enum Command {
@@ -33,6 +40,23 @@ pub enum Command {
Register(String), Register(String),
Unregister(i32), Unregister(i32),
AddItem(i32, String), AddItem(i32, String),
AddWithContext {
server: i32,
definition: String,
context: String,
buffered: bool,
},
SetBufferedInterval(i32, i32),
Activation {
server: i32,
item: i32,
active: bool,
},
Authenticate(i32, String, String),
UserToId(i32, String),
SubscribeBulk(i32, Vec<String>, bool),
ItemBulk(i32, Vec<i32>, ItemOperation),
ReadBulk(i32, Vec<String>, Duration),
RemoveItem(i32, i32), RemoveItem(i32, i32),
Advise { Advise {
server: i32, server: i32,
@@ -44,6 +68,14 @@ pub enum Command {
UnAdvise(i32, i32), UnAdvise(i32, i32),
} }
#[derive(Clone, Copy)]
pub enum ItemOperation {
Advise,
UnAdvise,
Remove,
Unsubscribe,
}
pub enum WriteAccess { pub enum WriteAccess {
Plain(i32), Plain(i32),
Secured { current_user: i32, verifier: i32 }, Secured { current_user: i32, verifier: i32 },
@@ -75,6 +107,9 @@ impl From<WriteValueError> for CommandError {
pub enum CommandResult { pub enum CommandResult {
Done, Done,
Handle(i32), Handle(i32),
Status(MxStatusProxy),
SubscribeBulk(Vec<SubscribeResult>),
ReadBulk(Vec<BulkReadResult>),
Write(WriteCompletion), Write(WriteCompletion),
WriteBulk(Vec<BulkWriteResult>), WriteBulk(Vec<BulkWriteResult>),
} }
@@ -278,27 +313,45 @@ struct ProxyVtable {
unadvise: unsafe extern "system" fn(*mut c_void, i32, i32) -> HRESULT, unadvise: unsafe extern "system" fn(*mut c_void, i32, i32) -> HRESULT,
write: unsafe extern "system" fn(*mut c_void, i32, i32, VARIANT, i32) -> HRESULT, write: unsafe extern "system" fn(*mut c_void, i32, i32, VARIANT, i32) -> HRESULT,
write_secured: unsafe extern "system" fn(*mut c_void, i32, i32, i32, i32, VARIANT) -> HRESULT, write_secured: unsafe extern "system" fn(*mut c_void, i32, i32, i32, i32, VARIANT) -> HRESULT,
authenticate_user: usize, authenticate_user: unsafe extern "system" fn(*mut c_void, i32, BSTR, BSTR, *mut i32) -> HRESULT,
}
#[repr(C)]
struct ProxyV2Vtable {
base: ProxyVtable,
archestra_user_to_id: unsafe extern "system" fn(*mut c_void, i32, BSTR, *mut i32) -> HRESULT,
}
#[repr(C)]
struct ProxyV3Vtable {
base: ProxyV2Vtable,
add_item2: unsafe extern "system" fn(*mut c_void, i32, BSTR, BSTR, *mut i32) -> HRESULT,
} }
#[repr(C)] #[repr(C)]
struct ProxyV4Vtable { struct ProxyV4Vtable {
base: ProxyVtable, base: ProxyV3Vtable,
archestra_user_to_id: usize,
add_item2: usize,
write2: unsafe extern "system" fn(*mut c_void, i32, i32, VARIANT, VARIANT, i32) -> HRESULT, write2: unsafe extern "system" fn(*mut c_void, i32, i32, VARIANT, VARIANT, i32) -> HRESULT,
write_secured2: write_secured2:
unsafe extern "system" fn(*mut c_void, i32, i32, i32, i32, VARIANT, VARIANT) -> HRESULT, unsafe extern "system" fn(*mut c_void, i32, i32, i32, i32, VARIANT, VARIANT) -> HRESULT,
suspend: usize, suspend: unsafe extern "system" fn(*mut c_void, i32, i32, *mut StatusRecord) -> HRESULT,
activate: usize, activate: unsafe extern "system" fn(*mut c_void, i32, i32, *mut StatusRecord) -> HRESULT,
advise_supervisory: unsafe extern "system" fn(*mut c_void, i32, i32) -> HRESULT, advise_supervisory: unsafe extern "system" fn(*mut c_void, i32, i32) -> HRESULT,
} }
#[repr(C)]
struct ProxyV5Vtable {
base: ProxyV4Vtable,
add_buffered_item: unsafe extern "system" fn(*mut c_void, i32, BSTR, BSTR, *mut i32) -> HRESULT,
set_buffered_update_interval: 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, publisher: Publisher,
connection: Option<Connection>, connections: Vec<Connection>,
items: BTreeMap<(i32, i32), String>,
} }
impl Proxy { impl Proxy {
@@ -318,10 +371,15 @@ impl Proxy {
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, publisher,
connection: None, connections: Vec::new(),
items: BTreeMap::new(),
}; };
// SAFETY: this STA owns the live proxy and its connection point. // SAFETY: this STA owns the live proxy and its connection point.
proxy.connection = Some(unsafe { Connection::attach(interface, proxy.publisher.clone()) }?); for buffered in [false, true] {
proxy
.connections
.push(unsafe { Connection::attach(interface, proxy.publisher.clone(), buffered) }?);
}
Ok(proxy) Ok(proxy)
} }
@@ -354,23 +412,137 @@ impl Proxy {
.map_err(CommandError::HResult)?; .map_err(CommandError::HResult)?;
self.registrations.remove(&server); self.registrations.remove(&server);
self.publisher.unregister(server); self.publisher.unregister(server);
self.items.retain(|(handle, _), _| *handle != server);
Ok(CommandResult::Done) Ok(CommandResult::Done)
} }
Command::AddItem(server, definition) => { Command::AddItem(server, definition_text) => {
self.require_registration(server)?; self.require_registration(server)?;
let definition = let definition =
AutomationString::new(&definition).map_err(CommandError::HResult)?; AutomationString::new(&definition_text).map_err(CommandError::HResult)?;
check(unsafe { check(unsafe {
(table.add_item)(object, server, definition.as_raw(), &mut handle) (table.add_item)(object, server, definition.as_raw(), &mut handle)
}) })
.map_err(CommandError::HResult)?; .map_err(CommandError::HResult)?;
self.items.insert((server, handle), definition_text);
Ok(CommandResult::Handle(handle)) Ok(CommandResult::Handle(handle))
} }
Command::AddWithContext {
server,
definition,
context,
buffered,
} => {
self.require_registration(server)?;
let item = AutomationString::new(&definition).map_err(CommandError::HResult)?;
let context_value =
AutomationString::new(&context).map_err(CommandError::HResult)?;
let status = if buffered {
let extended = self.query(&IID_V5).map_err(CommandError::HResult)?;
unsafe {
(interface_table::<ProxyV5Vtable>(&extended).add_buffered_item)(
extended.as_ptr(),
server,
item.as_raw(),
context_value.as_raw(),
&mut handle,
)
}
} else {
let extended = self.query(&IID_V3).map_err(CommandError::HResult)?;
// The V3 vtable ends at AddItem2. Only the prefix containing that slot is read.
let table = unsafe { interface_table::<ProxyV3Vtable>(&extended) };
unsafe {
(table.add_item2)(
extended.as_ptr(),
server,
item.as_raw(),
context_value.as_raw(),
&mut handle,
)
}
};
check(status).map_err(CommandError::HResult)?;
// Context is an input to the native resolver; the C# index keys the item definition.
self.items.insert((server, handle), definition);
Ok(CommandResult::Handle(handle))
}
Command::SetBufferedInterval(server, interval) => {
self.require_registration(server)?;
let extended = self.query(&IID_V5).map_err(CommandError::HResult)?;
check(unsafe {
(interface_table::<ProxyV5Vtable>(&extended).set_buffered_update_interval)(
extended.as_ptr(),
server,
interval,
)
})
.map_err(CommandError::HResult)?;
Ok(CommandResult::Done)
}
Command::Activation {
server,
item,
active,
} => {
self.require_registration(server)?;
let extended = self.extended().map_err(CommandError::HResult)?;
let table = extended_table(&extended);
let method = if active {
table.activate
} else {
table.suspend
};
let mut status = StatusRecord::default();
check(unsafe { method(extended.as_ptr(), server, item, &mut status) })
.map_err(CommandError::HResult)?;
Ok(CommandResult::Status(status.to_proto()))
}
Command::Authenticate(server, user, password) => {
self.require_registration(server)?;
let user = AutomationString::new(&user).map_err(CommandError::HResult)?;
let password = AutomationString::new(&password).map_err(CommandError::HResult)?;
check(unsafe {
(table.authenticate_user)(
object,
server,
user.as_raw(),
password.as_raw(),
&mut handle,
)
})
.map_err(CommandError::HResult)?;
Ok(CommandResult::Handle(handle))
}
Command::UserToId(server, guid) => {
self.require_registration(server)?;
let guid = AutomationString::new(&guid).map_err(CommandError::HResult)?;
let extended = self.query(&IID_V2).map_err(CommandError::HResult)?;
check(unsafe {
(interface_table::<ProxyV2Vtable>(&extended).archestra_user_to_id)(
extended.as_ptr(),
server,
guid.as_raw(),
&mut handle,
)
})
.map_err(CommandError::HResult)?;
Ok(CommandResult::Handle(handle))
}
Command::SubscribeBulk(server, tags, advise) => Ok(CommandResult::SubscribeBulk(
self.subscribe_bulk(server, tags, advise),
)),
Command::ItemBulk(server, handles, operation) => Ok(CommandResult::SubscribeBulk(
self.item_bulk(server, handles, operation),
)),
Command::ReadBulk(server, tags, timeout) => Ok(CommandResult::ReadBulk(
self.read_bulk(server, tags, timeout),
)),
Command::RemoveItem(server, item) => { Command::RemoveItem(server, item) => {
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); self.publisher.unadvise(server, item);
self.items.remove(&(server, item));
Ok(CommandResult::Done) Ok(CommandResult::Done)
} }
Command::Advise { Command::Advise {
@@ -509,6 +681,7 @@ impl Proxy {
match self.write(request, false) { match self.write(request, false) {
Ok(_) => result.was_successful = true, Ok(_) => result.was_successful = true,
Err(CommandError::NotRegistered) => { Err(CommandError::NotRegistered) => {
result.hresult = Some(E_INVALIDARG);
result.error_message = "Server handle is not registered in this session".into() result.error_message = "Server handle is not registered in this session".into()
} }
Err(CommandError::Invalid(message)) => result.error_message = message.into(), Err(CommandError::Invalid(message)) => result.error_message = message.into(),
@@ -522,10 +695,14 @@ impl Proxy {
} }
fn extended(&self) -> Result<ComReference, HRESULT> { fn extended(&self) -> Result<ComReference, HRESULT> {
self.query(&IID_V4)
}
fn query(&self, iid: &GUID) -> Result<ComReference, HRESULT> {
let mut pointer = null_mut(); let mut pointer = null_mut();
// SAFETY: this is a live proxy on its STA. The IID matches ProxyV4Vtable. // SAFETY: this is a live proxy on its STA. The IID matches ProxyV4Vtable.
check(unsafe { check(unsafe {
(self.vtable().query_interface)(self.interface.as_ptr(), &IID_V4, &mut pointer) (self.vtable().query_interface)(self.interface.as_ptr(), iid, &mut pointer)
})?; })?;
ComReference::new(pointer) ComReference::new(pointer)
} }
@@ -542,7 +719,7 @@ impl Proxy {
self.publisher.discard_pending_write(); self.publisher.discard_pending_write();
let advice = self.publisher.take_advice(); let advice = self.publisher.take_advice();
let mut failures = 0; let mut failures = 0;
if let Some(mut connection) = self.connection.take() { for mut connection in self.connections.drain(..) {
if let Err(hr) = connection.detach() { if let Err(hr) = connection.detach() {
failures += 1; failures += 1;
eprintln!( eprintln!(
@@ -584,7 +761,7 @@ impl Proxy {
impl Drop for Proxy { impl Drop for Proxy {
fn drop(&mut self) { fn drop(&mut self) {
drop(self.connection.take()); self.connections.clear();
// 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()) };
} }
@@ -592,7 +769,12 @@ impl Drop for Proxy {
fn extended_table(reference: &ComReference) -> &ProxyV4Vtable { fn extended_table(reference: &ComReference) -> &ProxyV4Vtable {
// SAFETY: the reference was obtained for IID_V4 by Proxy::extended. // SAFETY: the reference was obtained for IID_V4 by Proxy::extended.
unsafe { &**reference.as_ptr().cast::<*const ProxyV4Vtable>() } unsafe { interface_table::<ProxyV4Vtable>(reference) }
}
unsafe fn interface_table<V>(reference: &ComReference) -> &V {
// SAFETY: caller selects the vtable matching QueryInterface's IID.
unsafe { &**reference.as_ptr().cast::<*const V>() }
} }
fn check(status: HRESULT) -> Result<(), HRESULT> { fn check(status: HRESULT) -> Result<(), HRESULT> {
@@ -0,0 +1,262 @@
use super::*;
use crate::wire::mxaccess_gateway::v1::MxEvent;
use std::time::Instant;
impl Proxy {
pub(super) fn subscribe_bulk(
&mut self,
server: i32,
tags: Vec<String>,
advise: bool,
) -> Vec<SubscribeResult> {
tags.into_iter()
.map(|tag| {
let mut result = SubscribeResult {
server_handle: server,
tag_address: tag,
..Default::default()
};
if result.tag_address.trim().is_empty() {
result.error_message = "Tag address is required.".into();
return result;
}
match self.add_item_handle(server, &result.tag_address) {
Ok(item) => {
result.item_handle = item;
if advise {
if let Err(error) = self.advise_item(server, item) {
result.error_message = error.message();
if let Err(cleanup) =
self.execute(Command::RemoveItem(server, item))
{
result.error_message.push_str(&format!(
"; cleanup RemoveItem failed: {}",
cleanup.message()
));
}
return result;
}
}
result.was_successful = true;
}
Err(error) => result.error_message = error.message(),
}
result
})
.collect()
}
pub(super) fn item_bulk(
&mut self,
server: i32,
items: Vec<i32>,
operation: ItemOperation,
) -> Vec<SubscribeResult> {
items
.into_iter()
.map(|item| {
let mut result = SubscribeResult {
server_handle: server,
item_handle: item,
..Default::default()
};
result.error_message = match operation {
ItemOperation::Advise => self
.advise_item(server, item)
.err()
.map_or_else(String::new, |err| err.message()),
ItemOperation::UnAdvise => self
.execute(Command::UnAdvise(server, item))
.err()
.map_or_else(String::new, |err| err.message()),
ItemOperation::Remove => self
.execute(Command::RemoveItem(server, item))
.err()
.map_or_else(String::new, |err| err.message()),
ItemOperation::Unsubscribe => {
let unadvise = self.execute(Command::UnAdvise(server, item));
let remove = self.execute(Command::RemoveItem(server, item));
[("UnAdvise", unadvise), ("RemoveItem", remove)]
.into_iter()
.filter_map(|(operation, result)| {
result
.err()
.map(|error| format!("{operation} failed: {}", error.message()))
})
.collect::<Vec<_>>()
.join("; ")
}
};
result.was_successful = result.error_message.is_empty();
result
})
.collect()
}
pub(super) fn read_bulk(
&mut self,
server: i32,
tags: Vec<String>,
timeout: Duration,
) -> Vec<BulkReadResult> {
let original_items: BTreeSet<_> = self
.items
.keys()
.filter_map(|&(handle, item)| (handle == server).then_some(item))
.collect();
let mut results = Vec::with_capacity(tags.len());
let mut waiting = Vec::new();
let mut cleanup = BTreeMap::new();
let mut seen_tags = BTreeMap::new();
for tag in tags {
let index = results.len();
let mut result = BulkReadResult {
server_handle: server,
tag_address: tag,
..Default::default()
};
if result.tag_address.trim().is_empty() {
result.error_message = "Tag address is required.".into();
} else if let Some((item, event)) = self
.items
.range((server, i32::MIN)..=(server, i32::MAX))
.filter(|(_, definition)| definition.as_str() == result.tag_address.as_str())
.find_map(|(&(_, item), _)| {
// Only original items count as a cached read for this command.
original_items
.contains(&item)
.then(|| self.publisher.latest_value(server, item))
.flatten()
.map(|event| (item, event))
})
{
result.item_handle = item;
result.was_cached = true;
fill_value(&mut result, event);
} else if let Some(&owner) = seen_tags.get(&result.tag_address) {
// A repeated address shares the same snapshot and outcome.
waiting.push((index, Some(owner)));
} else {
seen_tags.insert(result.tag_address.clone(), index);
match self.add_item_handle(server, &result.tag_address) {
Err(error) => result.error_message = error.message(),
Ok(item) => {
result.item_handle = item;
let already_advised = self.publisher.is_advised(server, item);
if let std::collections::btree_map::Entry::Vacant(entry) =
cleanup.entry(item)
{
let advice = if already_advised {
Ok(())
} else {
self.advise_item(server, item)
};
entry.insert((
!original_items.contains(&item),
!already_advised && advice.is_ok(),
));
if let Err(error) = advice {
result.error_message = error.message();
}
}
if result.error_message.is_empty() {
waiting.push((index, None));
}
}
}
}
results.push(result);
if index % 16 == 15 {
pump_messages();
}
}
let deadline = Instant::now() + timeout;
while pump_messages()
&& waiting.iter().any(|&(index, owner)| {
owner.is_none()
&& self
.publisher
.latest_value(server, results[index].item_handle)
.is_none()
})
{
let remaining = deadline.saturating_duration_since(Instant::now());
if remaining.is_zero() {
break;
}
// The STA remains available to deliver the OnDataChange callbacks.
unsafe {
MsgWaitForMultipleObjectsEx(
0,
null(),
remaining.as_millis().min(u32::MAX as u128 - 1) as u32,
QS_ALLINPUT,
MWMO_INPUTAVAILABLE,
);
}
}
for (index, owner) in waiting {
if let Some(owner) = owner {
let tag = std::mem::take(&mut results[index].tag_address);
results[index] = results[owner].clone();
results[index].tag_address = tag;
} else if let Some(event) = self
.publisher
.latest_value(server, results[index].item_handle)
{
fill_value(&mut results[index], event);
} else {
results[index].error_message = format!(
"ReadBulk timed out after {} ms waiting for first OnDataChange.",
timeout.as_millis()
);
}
}
for (item, (remove, unadvise)) in cleanup {
if unadvise {
let _ = self.execute(Command::UnAdvise(server, item));
}
if remove {
let _ = self.execute(Command::RemoveItem(server, item));
}
}
results
}
fn add_item_handle(&mut self, server: i32, address: &str) -> Result<i32, CommandError> {
match self.execute(Command::AddItem(server, address.into()))? {
CommandResult::Handle(handle) => Ok(handle),
_ => unreachable!("AddItem returns a handle"),
}
}
fn advise_item(&mut self, server: i32, item: i32) -> Result<(), CommandError> {
self.execute(Command::Advise {
server,
item,
supervisory: false,
})
.map(|_| ())
}
}
fn fill_value(result: &mut BulkReadResult, event: MxEvent) {
result.was_successful = true;
result.value = event.value;
result.quality = event.quality;
result.source_timestamp = event.source_timestamp;
result.statuses = event.statuses;
}
impl CommandError {
fn message(&self) -> String {
match self {
Self::NotRegistered => "Server handle is not registered in this session".into(),
Self::Invalid(message) => (*message).into(),
Self::HResult(hr) => format!("MXAccess command failed (HRESULT 0x{:08X})", *hr as u32),
}
}
}
+178 -19
View File
@@ -1,4 +1,4 @@
use std::collections::BTreeSet; use std::collections::{BTreeMap, BTreeSet};
use std::ffi::c_void; use std::ffi::c_void;
use std::ptr::{null_mut, NonNull}; use std::ptr::{null_mut, NonNull};
use std::sync::{ use std::sync::{
@@ -17,13 +17,17 @@ use windows_sys::Win32::System::Com::{DISPPARAMS, EXCEPINFO};
use windows_sys::Win32::System::Ole::{GetRecordInfoFromGuids, LoadRegTypeLib}; use windows_sys::Win32::System::Ole::{GetRecordInfoFromGuids, LoadRegTypeLib};
use windows_sys::Win32::System::Variant::VARIANT; use windows_sys::Win32::System::Variant::VARIANT;
use crate::automation::{dispatch_i32, dispatch_statuses, dispatch_timestamp, dispatch_value}; use crate::automation::{
buffered_array, dispatch_i32, dispatch_statuses, dispatch_timestamp, dispatch_value,
native_data_type,
};
use crate::wire::mxaccess_gateway::v1::{ use crate::wire::mxaccess_gateway::v1::{
mx_event, MxEvent, MxEventFamily, MxStatusProxy, OnDataChangeEvent, OnWriteCompleteEvent, mx_event, mx_value, MxDataType, MxEvent, MxEventFamily, MxStatusProxy,
OperationCompleteEvent, OnBufferedDataChangeEvent, OnDataChangeEvent, OnWriteCompleteEvent, OperationCompleteEvent,
}; };
const EVENTS_IID: GUID = GUID::from_u128(0x848299b6_dd61_4a0d_a304_3947a564b89c); const EVENTS_IID: GUID = GUID::from_u128(0x848299b6_dd61_4a0d_a304_3947a564b89c);
const BUFFERED_EVENTS_IID: GUID = GUID::from_u128(0xc70a6fc4_09ef_4f31_8874_a049fee87a95);
const DISPATCH_IID: GUID = GUID::from_u128(0x00020400_0000_0000_c000_000000000046); const DISPATCH_IID: GUID = GUID::from_u128(0x00020400_0000_0000_c000_000000000046);
const CONNECTION_POINT_CONTAINER_IID: GUID = const CONNECTION_POINT_CONTAINER_IID: GUID =
GUID::from_u128(0xb196b284_bab4_101a_b69c_00aa00341d07); GUID::from_u128(0xb196b284_bab4_101a_b69c_00aa00341d07);
@@ -33,6 +37,7 @@ const RECORD_ID: GUID = GUID::from_u128(0xa162d9e4_9019_42f3_a087_79264007e542);
#[derive(Clone, Copy)] #[derive(Clone, Copy)]
pub enum EventFault { pub enum EventFault {
Overflow, Overflow,
AlarmDisconnected,
Conversion(&'static str), Conversion(&'static str),
} }
@@ -56,6 +61,7 @@ struct PendingWrite {
struct PublisherState { struct PublisherState {
advised: BTreeSet<(i32, i32)>, advised: BTreeSet<(i32, i32)>,
last_sequence: u64, last_sequence: u64,
latest_values: BTreeMap<(i32, i32), MxEvent>,
pending_write: Option<PendingWrite>, pending_write: Option<PendingWrite>,
} }
@@ -87,15 +93,26 @@ impl Publisher {
} }
pub fn unadvise(&self, server: i32, item: i32) { pub fn unadvise(&self, server: i32, item: i32) {
self.state.lock().unwrap().advised.remove(&(server, item)); let mut state = self.state.lock().unwrap();
state.advised.remove(&(server, item));
state.latest_values.remove(&(server, item));
} }
pub fn unregister(&self, server: i32) { pub fn unregister(&self, server: i32) {
let mut state = self.state.lock().unwrap();
state.advised.retain(|(handle, _)| *handle != server);
state
.latest_values
.retain(|(handle, _), _| *handle != server);
}
pub fn latest_value(&self, server: i32, item: i32) -> Option<MxEvent> {
self.state self.state
.lock() .lock()
.unwrap() .unwrap()
.advised .latest_values
.retain(|(handle, _)| *handle != server); .get(&(server, item))
.cloned()
} }
pub fn take_advice(&self) -> BTreeSet<(i32, i32)> { pub fn take_advice(&self) -> BTreeSet<(i32, i32)> {
@@ -106,11 +123,11 @@ impl Publisher {
self.state.lock().unwrap().last_sequence self.state.lock().unwrap().last_sequence
} }
fn is_advised(&self, server: i32, item: i32) -> bool { pub(crate) fn is_advised(&self, server: i32, item: i32) -> bool {
self.state.lock().unwrap().advised.contains(&(server, item)) self.state.lock().unwrap().advised.contains(&(server, item))
} }
fn report_fault(&self, fault: EventFault) { pub(crate) fn report_fault(&self, fault: EventFault) {
self.faults.send_if_modified(|current| { self.faults.send_if_modified(|current| {
if current.is_some() { if current.is_some() {
return false; return false;
@@ -134,11 +151,18 @@ impl Publisher {
self.state.lock().unwrap().pending_write.take(); self.state.lock().unwrap().pending_write.take();
} }
fn publish(&self, mut event: MxEvent) { pub(crate) fn publish(&self, mut event: MxEvent) {
let mut state = self.state.lock().unwrap(); let mut state = self.state.lock().unwrap();
event.session_id = self.session.to_string(); event.session_id = self.session.to_string();
event.worker_timestamp = Some(SystemTime::now().into()); event.worker_timestamp = Some(SystemTime::now().into());
event.worker_sequence = state.last_sequence + 1; event.worker_sequence = state.last_sequence + 1;
if event.family() == MxEventFamily::OnDataChange {
let key = (event.server_handle, event.item_handle);
if !state.advised.contains(&key) {
return;
}
state.latest_values.insert(key, event.clone());
}
if event.family() == MxEventFamily::OnWriteComplete if event.family() == MxEventFamily::OnWriteComplete
&& state.pending_write.as_ref().is_some_and(|pending| { && state.pending_write.as_ref().is_some_and(|pending| {
pending.server == event.server_handle && pending.item == event.item_handle pending.server == event.server_handle && pending.item == event.item_handle
@@ -181,7 +205,16 @@ pub struct Connection {
impl Connection { impl Connection {
// The caller supplies the live LMXProxy interface on the owning STA. // The caller supplies the live LMXProxy interface on the owning STA.
pub unsafe fn attach(proxy: *mut c_void, publisher: Publisher) -> Result<Self, HRESULT> { pub unsafe fn attach(
proxy: *mut c_void,
publisher: Publisher,
buffered: bool,
) -> Result<Self, HRESULT> {
let events_iid = if buffered {
BUFFERED_EVENTS_IID
} else {
EVENTS_IID
};
let mut container = null_mut(); let mut container = null_mut();
let unknown = unsafe { vtable::<IUnknown_Vtbl>(proxy) }; let unknown = unsafe { vtable::<IUnknown_Vtbl>(proxy) };
check(unsafe { check(unsafe {
@@ -191,12 +224,13 @@ impl Connection {
let mut point = null_mut(); let mut point = null_mut();
let table = unsafe { vtable::<ConnectionPointContainerVtable>(container.as_ptr()) }; let table = unsafe { vtable::<ConnectionPointContainerVtable>(container.as_ptr()) };
check(unsafe { check(unsafe {
(table.find_connection_point)(container.as_ptr(), &EVENTS_IID, &mut point) (table.find_connection_point)(container.as_ptr(), &events_iid, &mut point)
})?; })?;
let point = ComReference::new(point)?; let point = ComReference::new(point)?;
let sink = Box::new(Sink { let sink = Box::new(Sink {
table: &SINK_VTABLE, table: &SINK_VTABLE,
buffered,
reference_count: AtomicU32::new(1), reference_count: AtomicU32::new(1),
publisher, publisher,
}); });
@@ -289,6 +323,7 @@ fn check(hr: HRESULT) -> Result<(), HRESULT> {
#[repr(C)] #[repr(C)]
struct Sink { struct Sink {
table: &'static DispatchVtable, table: &'static DispatchVtable,
buffered: bool,
reference_count: AtomicU32, reference_count: AtomicU32,
publisher: Publisher, publisher: Publisher,
} }
@@ -343,7 +378,13 @@ unsafe extern "system" fn query_interface(
let Some(iid) = (unsafe { iid.as_ref() }) else { let Some(iid) = (unsafe { iid.as_ref() }) else {
return E_POINTER; return E_POINTER;
}; };
if [EVENTS_IID, DISPATCH_IID, IID_IUnknown] let sink = unsafe { &*this.cast::<Sink>() };
let events_iid = if sink.buffered {
BUFFERED_EVENTS_IID
} else {
EVENTS_IID
};
if [events_iid, DISPATCH_IID, IID_IUnknown]
.iter() .iter()
.any(|supported| { .any(|supported| {
supported.data1 == iid.data1 supported.data1 == iid.data1
@@ -430,18 +471,23 @@ unsafe extern "system" fn invoke(
impl Sink { impl Sink {
unsafe fn on_dispatch(&self, member: i32, parameters: *const DISPPARAMS) -> HRESULT { unsafe fn on_dispatch(&self, member: i32, parameters: *const DISPPARAMS) -> HRESULT {
let (count, family, body) = match member { let (count, family, body) = match (self.buffered, member) {
1 => ( (true, 1) => (
7,
MxEventFamily::OnBufferedDataChange,
mx_event::Body::OnBufferedDataChange(OnBufferedDataChangeEvent::default()),
),
(false, 1) => (
6, 6,
MxEventFamily::OnDataChange, MxEventFamily::OnDataChange,
mx_event::Body::OnDataChange(OnDataChangeEvent {}), mx_event::Body::OnDataChange(OnDataChangeEvent {}),
), ),
2 => ( (false, 2) => (
3, 3,
MxEventFamily::OnWriteComplete, MxEventFamily::OnWriteComplete,
mx_event::Body::OnWriteComplete(OnWriteCompleteEvent {}), mx_event::Body::OnWriteComplete(OnWriteCompleteEvent {}),
), ),
3 => ( (false, 3) => (
3, 3,
MxEventFamily::OperationComplete, MxEventFamily::OperationComplete,
mx_event::Body::OperationComplete(OperationCompleteEvent {}), mx_event::Body::OperationComplete(OperationCompleteEvent {}),
@@ -460,7 +506,7 @@ impl Sink {
// IDispatch packs its positional arguments in reverse order. LMXProxy // IDispatch packs its positional arguments in reverse order. LMXProxy
// puts them at four-byte aligned addresses on x86, so copy them before // puts them at four-byte aligned addresses on x86, so copy them before
// forming Rust references to the eight-byte-aligned VARIANT type. // forming Rust references to the eight-byte-aligned VARIANT type.
let mut args = [VARIANT::default(); 6]; let mut args = [VARIANT::default(); 7];
for (index, argument) in args[..count].iter_mut().enumerate() { for (index, argument) in args[..count].iter_mut().enumerate() {
*argument = unsafe { parameters.rgvarg.add(index).read_unaligned() }; *argument = unsafe { parameters.rgvarg.add(index).read_unaligned() };
} }
@@ -490,7 +536,32 @@ impl Sink {
body: Some(body), body: Some(body),
..Default::default() ..Default::default()
}; };
if member == 1 { if self.buffered {
let Some(raw_data_type) = (unsafe { dispatch_i32(&args[4]) }) else {
self.publisher.report_fault(EventFault::Conversion(
"unexpected buffered MXAccess data type",
));
return DISP_E_TYPEMISMATCH;
};
let data_type = native_data_type(raw_data_type);
let mut value = unsafe { dispatch_value(&args[3]) };
if let Some(mx_value::Kind::ArrayValue(array)) = &mut value.kind {
if data_type != MxDataType::NoData as i32 && data_type != MxDataType::Unknown as i32
{
// Inferred Automation scalar/array types remain available on the value.
array.raw_element_data_type = raw_data_type;
}
}
event.value = Some(value);
event.body = Some(mx_event::Body::OnBufferedDataChange(
OnBufferedDataChangeEvent {
data_type,
raw_data_type,
quality_values: Some(unsafe { buffered_array(&args[2], MxDataType::Integer) }),
timestamp_values: Some(unsafe { buffered_array(&args[1], MxDataType::Time) }),
},
));
} else if member == 1 {
let Some(quality) = (unsafe { dispatch_i32(&args[2]) }) else { let Some(quality) = (unsafe { dispatch_i32(&args[2]) }) else {
self.publisher self.publisher
.report_fault(EventFault::Conversion("unexpected MXAccess quality type")); .report_fault(EventFault::Conversion("unexpected MXAccess quality type"));
@@ -520,6 +591,7 @@ mod tests {
let (publisher, mut events, faults) = event_channel("session", 1); let (publisher, mut events, faults) = event_channel("session", 1);
let sink = Sink { let sink = Sink {
table: &SINK_VTABLE, table: &SINK_VTABLE,
buffered: false,
reference_count: AtomicU32::new(1), reference_count: AtomicU32::new(1),
publisher, publisher,
}; };
@@ -602,6 +674,93 @@ mod tests {
assert_eq!(events.try_recv().unwrap().statuses, statuses); assert_eq!(events.try_recv().unwrap().statuses, statuses);
} }
#[test]
fn preserves_buffered_samples_quality_and_filetime_timestamps() {
use crate::automation::WriteValue;
use crate::wire::mxaccess_gateway::v1::{
mx_array::Values, Int32Array, Int64Array, MxArray, MxValue,
};
let (publisher, mut events, _) = event_channel("session", 4);
let sink = Sink {
table: &SINK_VTABLE,
buffered: true,
reference_count: AtomicU32::new(1),
publisher,
};
sink.publisher.advise(5, 7);
let array = |values| {
WriteValue::new(
MxValue {
kind: Some(mx_value::Kind::ArrayValue(MxArray {
dimensions: vec![2],
values: Some(values),
..Default::default()
})),
..Default::default()
},
false,
)
.unwrap()
};
let samples = array(Values::Int32Values(Int32Array {
values: vec![40, 41],
}));
let qualities = array(Values::Int32Values(Int32Array {
values: vec![192, 0],
}));
let times = array(Values::Int64Values(Int64Array {
values: vec![116_444_736_000_000_000, 116_444_736_010_000_000],
}));
let mut arguments = [
VARIANT::default(),
times.by_value(),
qualities.by_value(),
samples.by_value(),
integer(2),
integer(7),
integer(5),
];
let parameters = DISPPARAMS {
rgvarg: arguments.as_mut_ptr(),
cArgs: 7,
..Default::default()
};
assert_eq!(unsafe { sink.on_dispatch(1, &parameters) }, S_OK);
let event = events.try_recv().unwrap();
assert_eq!(event.family(), MxEventFamily::OnBufferedDataChange);
let Some(mx_value::Kind::ArrayValue(value)) = event.value.unwrap().kind else {
panic!("missing buffered values");
};
assert_eq!(
value.values,
Some(Values::Int32Values(Int32Array {
values: vec![40, 41]
}))
);
let Some(mx_event::Body::OnBufferedDataChange(body)) = event.body else {
panic!("missing buffered body");
};
assert_eq!(body.data_type, MxDataType::Integer as i32);
assert_eq!(
body.quality_values.unwrap().values,
Some(Values::Int32Values(Int32Array {
values: vec![192, 0]
}))
);
let Some(Values::TimestampValues(times)) = body.timestamp_values.unwrap().values else {
panic!("missing timestamps");
};
assert_eq!(
times
.values
.into_iter()
.map(|value| value.seconds)
.collect::<Vec<_>>(),
[0, 1]
);
}
fn integer(value: i32) -> VARIANT { fn integer(value: i32) -> VARIANT {
let mut result = VARIANT::default(); let mut result = VARIANT::default();
result.Anonymous.Anonymous.vt = VT_I4; result.Anonymous.Anonymous.vt = VT_I4;
+470 -81
View File
@@ -1,5 +1,6 @@
use std::collections::HashMap; use std::collections::HashMap;
use std::io; use std::io;
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime}; use std::time::{Duration, SystemTime};
use prost::Message; use prost::Message;
@@ -7,20 +8,24 @@ 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, watch}; use tokio::sync::{mpsc, watch};
use tokio::time::{interval, sleep, timeout, Instant, MissedTickBehavior}; use tokio::time::{interval, sleep, timeout, Instant, Interval, MissedTickBehavior};
use windows_sys::Win32::Foundation::E_INVALIDARG;
use crate::alarm::{self, AlarmWorker};
use crate::automation::int32; use crate::automation::int32;
use crate::mxaccess::{ use crate::mxaccess::{
Command, CommandError, CommandResult, Sta, StartError, WriteAccess, WriteRequest, CLASS_ID, Command, CommandError, CommandResult, ItemOperation, Sta, StartError, WriteAccess,
PROG_ID, WriteRequest, CLASS_ID, PROG_ID,
}; };
use crate::mxevent::{event_channel, EventFault, Publisher}; 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, AddItemReply, BulkWriteReply, DrainEventsReply, MxCommand, mx_command, mx_command_reply, ActivateReply, AddBufferedItemReply, AddItem2Reply,
MxCommandKind, MxCommandReply, MxEvent, ProtocolStatus, ProtocolStatusCode, RegisterReply, AddItemReply, ArchestrAUserToIdReply, AuthenticateUserReply, BulkReadReply,
SessionState, SessionStateReply, WorkerInfoReply, BulkSubscribeReply, BulkWriteReply, DrainEventsReply, MxCommand, MxCommandKind,
MxCommandReply, MxEvent, ProtocolStatus, ProtocolStatusCode, RegisterReply, SessionState,
SessionStateReply, SuspendReply, WorkerInfoReply,
}, },
mxaccess_worker::v1::{ mxaccess_worker::v1::{
GatewayHello, WorkerCommand, WorkerCommandReply, WorkerEvent, WorkerFault, GatewayHello, WorkerCommand, WorkerCommandReply, WorkerEvent, WorkerFault,
@@ -165,20 +170,6 @@ pub async fn run() -> Result<(), Error> {
let options = Options::load()?; let options = Options::load()?;
let (mut reader, sender) = split(connect(&options).await?); let (mut reader, sender) = split(connect(&options).await?);
let mut writer = Writer::new(sender); let mut writer = Writer::new(sender);
writer
.send(
&options.session,
"",
Body::WorkerHello(WorkerHello {
protocol_version: VERSION,
nonce: options.nonce.clone(),
worker_process_id: pid(),
worker_version: WORKER_VERSION.into(),
}),
DEFAULT_MAX,
)
.await?;
let hello = wire::read(&mut reader, &options.session, DEFAULT_MAX).await?; let hello = wire::read(&mut reader, &options.session, DEFAULT_MAX).await?;
let max = match check_hello(hello.body, &options.nonce) { let max = match check_hello(hello.body, &options.nonce) {
Ok(max) => max, Ok(max) => max,
@@ -196,6 +187,20 @@ pub async fn run() -> Result<(), Error> {
} }
}; };
writer
.send(
&options.session,
"",
Body::WorkerHello(WorkerHello {
protocol_version: VERSION,
nonce: options.nonce.clone(),
worker_process_id: pid(),
worker_version: WORKER_VERSION.into(),
}),
DEFAULT_MAX,
)
.await?;
let mut events = EventStream::new(&options); let mut events = EventStream::new(&options);
let (sta, pin_status) = match Sta::start(events.publisher.clone()).await { let (sta, pin_status) = match Sta::start(events.publisher.clone()).await {
Ok(started) => started, Ok(started) => started,
@@ -234,25 +239,64 @@ pub async fn run() -> Result<(), Error> {
) )
.await?; .await?;
// Run the frame reader independently so a heartbeat cannot cancel a partial read. // Keep reading cancellation frames while the STA is running a command.
let (incoming, mut frames) = mpsc::channel(1); let (incoming, frames) = mpsc::channel(128);
let pending = PendingCommands::default();
let reader_pending = pending.clone();
let session = options.session.clone(); let session = options.session.clone();
let reader_task = tokio::spawn(async move { let reader_task =
tokio::spawn(async move {
loop { loop {
let frame = wire::read(&mut reader, &session, max).await; let frame = wire::read(&mut reader, &session, max).await;
let end = frame.is_err(); let end = frame.is_err();
if let Ok(frame) = &frame {
match frame.body.as_ref() {
Some(Body::WorkerCancel(_)) => {
reader_pending.cancel(&frame.correlation_id);
continue;
}
Some(Body::WorkerCommand(command)) => {
if command.command.as_ref().is_some_and(|command| {
command.kind() == MxCommandKind::ShutdownWorker
}) {
reader_pending.cancel_all();
}
reader_pending.queue(&frame.correlation_id);
}
Some(Body::WorkerShutdown(_)) => reader_pending.cancel_all(),
_ => {}
}
}
if incoming.send(frame).await.is_err() || end { if incoming.send(frame).await.is_err() || end {
return; return;
} }
} }
}); });
let result = command_loop(&options, max, &sta, &mut writer, &mut frames, &mut events).await; let result = command_loop(
&options,
max,
&sta,
&mut writer,
CommandFrames { frames, pending },
&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 {
Ok(grace) => { Ok(grace) => {
let shutdown = timeout(grace, sta.shutdown()).await; let shutdown = timeout(grace, async {
let alarms = async {
match events.alarm_worker.take() {
Some(worker) => worker.shutdown(&options.session, max, grace).await,
None => Ok(0),
}
};
let (sta_result, alarm_result) = tokio::join!(sta.shutdown(), alarms);
Ok::<_, io::Error>(sta_result? + alarm_result?)
})
.await;
let (code, message) = match shutdown { let (code, message) = match shutdown {
Ok(Ok(0)) => (ProtocolStatusCode::Ok, "Graceful shutdown completed".into()), Ok(Ok(0)) => (ProtocolStatusCode::Ok, "Graceful shutdown completed".into()),
Ok(Ok(failures)) => ( Ok(Ok(failures)) => (
@@ -278,6 +322,7 @@ pub async fn run() -> Result<(), Error> {
.map_err(Error::from) .map_err(Error::from)
} }
Err(error) => { Err(error) => {
drop(events.alarm_worker.take());
let _ = timeout(Duration::from_secs(2), sta.shutdown()).await; let _ = timeout(Duration::from_secs(2), sta.shutdown()).await;
Err(error) Err(error)
} }
@@ -315,12 +360,51 @@ fn check_hello(
wire::negotiated_max(max_frame_bytes).map_err(|error| (ProtocolViolation, error.into())) wire::negotiated_max(max_frame_bytes).map_err(|error| (ProtocolViolation, error.into()))
} }
#[derive(Clone, Default)]
struct PendingCommands(Arc<Mutex<HashMap<String, bool>>>);
impl PendingCommands {
fn queue(&self, correlation: &str) {
self.0.lock().unwrap().insert(correlation.into(), false);
}
fn cancel(&self, correlation: &str) {
if let Some(canceled) = self.0.lock().unwrap().get_mut(correlation) {
*canceled = true;
}
}
fn cancel_all(&self) {
for canceled in self.0.lock().unwrap().values_mut() {
*canceled = true;
}
}
fn begin(&self, correlation: &str) -> bool {
!self
.0
.lock()
.unwrap()
.remove(correlation)
.unwrap_or_default()
}
fn count(&self) -> u32 {
self.0.lock().unwrap().len() as u32
}
}
struct CommandFrames {
frames: mpsc::Receiver<io::Result<wire::WorkerEnvelope>>,
pending: PendingCommands,
}
async fn command_loop<W: AsyncWrite + Unpin>( async fn command_loop<W: AsyncWrite + Unpin>(
options: &Options, options: &Options,
max: usize, max: usize,
sta: &Sta, sta: &Sta,
writer: &mut Writer<W>, writer: &mut Writer<W>,
frames: &mut mpsc::Receiver<io::Result<wire::WorkerEnvelope>>, mut commands: CommandFrames,
events: &mut EventStream, events: &mut EventStream,
) -> Result<Duration, Error> { ) -> Result<Duration, Error> {
let mut heartbeat = interval(options.heartbeat_interval); let mut heartbeat = interval(options.heartbeat_interval);
@@ -328,57 +412,29 @@ async fn command_loop<W: AsyncWrite + Unpin>(
loop { loop {
let callback_fault = *events.faults.borrow_and_update(); let callback_fault = *events.faults.borrow_and_update();
if let Some(failure) = callback_fault { if let Some(failure) = callback_fault {
let (category, message, exit_code) = match failure { return Err(report_event_fault(writer, &options.session, max, failure).await);
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, _ = events.faults.changed() => continue,
next = recv_event(&mut events.pending, &mut events.receiver) => { next = recv_event(&mut events.pending, &mut events.receiver) => {
let event = next.ok_or_else(|| Error(1, "MXAccess event channel closed".into()))?; send_event(writer, &options.session, max, next).await?;
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 = commands.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;
match frame.body.expect("reader validates body presence") { match frame.body.expect("reader validates body presence") {
Body::WorkerCommand(WorkerCommand { command, .. }) if !correlation.is_empty() => { Body::WorkerCommand(WorkerCommand { command, .. }) if !correlation.is_empty() => {
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 mut reply = if commands.pending.begin(&correlation) {
options.command_ceiling, run_command(
execute(sta, command, options, &correlation, events, max), sta, command, &correlation,
).await; CommandIo { options, max, writer, events, heartbeat: &mut heartbeat, pending: &commands.pending },
let mut reply = match execution { ).await?
Ok(Ok(reply)) => reply, } else {
Ok(Err(error)) => { let mut reply = command_reply(&options.session, &correlation, kind);
fault(writer, &options.session, max, WorkerFaultCategory::StaHung, None, &error.1).await; reply.hresult = None;
return Err(error); set_status(&mut reply, ProtocolStatusCode::Canceled, "Command was canceled before execution.");
} reply
Err(_) => {
let message = "MXAccess command exceeded the STA stuck ceiling";
fault(writer, &options.session, max, WorkerFaultCategory::StaHung, None, message).await;
return Err(Error(1, message.into()));
}
}; };
let shutdown = kind == MxCommandKind::ShutdownWorker as i32 let shutdown = kind == MxCommandKind::ShutdownWorker as i32
&& reply.protocol_status.as_ref().is_some_and(|status| status.code() == ProtocolStatusCode::Ok); && reply.protocol_status.as_ref().is_some_and(|status| status.code() == ProtocolStatusCode::Ok);
@@ -399,8 +455,6 @@ async fn command_loop<W: AsyncWrite + Unpin>(
.filter(|grace| !grace.is_zero()).unwrap_or(Duration::from_secs(10)); .filter(|grace| !grace.is_zero()).unwrap_or(Duration::from_secs(10));
return Ok(grace.min(Duration::from_secs(300))); return Ok(grace.min(Duration::from_secs(300)));
} }
// This slice has no pending COM work once control returns to the loop.
Body::WorkerCancel(_) => {}
_ => { _ => {
let message = "Unexpected gateway envelope or missing command correlation"; let message = "Unexpected gateway envelope or missing command correlation";
fault(writer, &options.session, max, WorkerFaultCategory::ProtocolViolation, None, message).await; fault(writer, &options.session, max, WorkerFaultCategory::ProtocolViolation, None, message).await;
@@ -418,6 +472,7 @@ 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()),
pending_command_count: commands.pending.count(),
outbound_event_queue_depth: events.depth() as u32, outbound_event_queue_depth: events.depth() as u32,
last_event_sequence: events.publisher.last_sequence(), last_event_sequence: events.publisher.last_sequence(),
..Default::default() ..Default::default()
@@ -427,14 +482,172 @@ async fn command_loop<W: AsyncWrite + Unpin>(
} }
} }
struct CommandIo<'a, W> {
options: &'a Options,
max: usize,
writer: &'a mut Writer<W>,
events: &'a mut EventStream,
heartbeat: &'a mut Interval,
pending: &'a PendingCommands,
}
async fn run_command<W: AsyncWrite + Unpin>(
sta: &Sta,
command: Option<MxCommand>,
correlation: &str,
io: CommandIo<'_, W>,
) -> Result<MxCommandReply, Error> {
let CommandIo {
options,
max,
writer,
events,
heartbeat,
pending,
} = io;
let drain = command.as_ref().and_then(|command| {
if command.kind() != MxCommandKind::DrainEvents {
return None;
}
let requested = match &command.payload {
Some(mx_command::Payload::DrainEvents(request)) => request.max_events,
None => 0,
_ => return None,
};
Some(events.drain(requested, max))
});
let context = ExecutorContext {
options,
max,
publisher: &events.publisher,
alarm_worker: &mut events.alarm_worker,
};
let execution = timeout(
options.command_ceiling,
execute(sta, command, correlation, context, drain),
);
tokio::pin!(execution);
let started = now();
loop {
tokio::select! {
biased;
result = &mut execution => {
return match result {
Ok(Ok(reply)) => Ok(reply),
failure => {
let error = match failure {
Ok(Err(error)) => error,
Err(_) => Error(1, "MXAccess command exceeded the STA stuck ceiling".into()),
Ok(Ok(_)) => unreachable!(),
};
fault(writer, &options.session, max, WorkerFaultCategory::StaHung, None, &error.1).await;
Err(error)
}
};
}
_ = events.faults.changed() => {
let failure = *events.faults.borrow_and_update();
if let Some(failure) = failure {
return Err(report_event_fault(writer, &options.session, max, failure).await);
}
}
_ = heartbeat.tick() => {
writer.send(&options.session, "", Body::WorkerHeartbeat(WorkerHeartbeat {
worker_process_id: pid(),
state: WorkerState::ExecutingCommand as i32,
last_sta_activity_timestamp: Some(started),
current_command_correlation_id: correlation.into(),
pending_command_count: pending.count(),
outbound_event_queue_depth: (events.receiver.len() + usize::from(events.pending.is_some())) as u32,
last_event_sequence: events.publisher.last_sequence(),
}), max).await?;
}
event = recv_event(&mut events.pending, &mut events.receiver) => {
send_event(writer, &options.session, max, event).await?;
}
}
}
}
async fn send_event(
writer: &mut Writer<impl AsyncWrite + Unpin>,
session: &str,
max: usize,
event: Option<MxEvent>,
) -> Result<(), Error> {
let event = event.ok_or_else(|| Error(1, "MXAccess event channel closed".into()))?;
let result = writer
.send(
session,
"",
Body::WorkerEvent(WorkerEvent { event: Some(event) }),
max,
)
.await;
if result
.as_ref()
.is_err_and(|error| error.kind() == io::ErrorKind::InvalidData)
{
fault(
writer,
session,
max,
WorkerFaultCategory::ProtocolViolation,
None,
"MXAccess event exceeds the negotiated frame maximum",
)
.await;
}
result.map_err(Error::from)
}
async fn report_event_fault(
writer: &mut Writer<impl AsyncWrite + Unpin>,
session: &str,
max: usize,
failure: EventFault,
) -> Error {
let (category, message, exit_code) = match failure {
EventFault::Overflow => (
WorkerFaultCategory::QueueOverflow,
"MXAccess event backlog exceeded the outbound queue capacity",
8,
),
EventFault::AlarmDisconnected => (
WorkerFaultCategory::PipeDisconnected,
"Managed alarm worker disconnected",
5,
),
EventFault::Conversion(message) => (
WorkerFaultCategory::MxaccessEventConversionFailed,
message,
1,
),
};
fault(writer, session, max, category, None, message).await;
Error(exit_code, message.into())
}
struct ExecutorContext<'a> {
options: &'a Options,
max: usize,
publisher: &'a Publisher,
alarm_worker: &'a mut Option<AlarmWorker>,
}
async fn execute( async fn execute(
sta: &Sta, sta: &Sta,
command: Option<MxCommand>, command: Option<MxCommand>,
options: &Options,
correlation: &str, correlation: &str,
events: &mut EventStream, context: ExecutorContext<'_>,
max: usize, drain: Option<DrainEventsReply>,
) -> Result<MxCommandReply, Error> { ) -> Result<MxCommandReply, Error> {
let ExecutorContext {
options,
max,
publisher,
alarm_worker,
} = context;
use mx_command::Payload; use mx_command::Payload;
use mx_command_reply::Payload as Reply; use mx_command_reply::Payload as Reply;
use MxCommandKind as Kind; use MxCommandKind as Kind;
@@ -453,6 +666,44 @@ async fn execute(
return Ok(reply); return Ok(reply);
}; };
let kind = command.kind(); let kind = command.kind();
if alarm::handles(kind) {
if alarm_worker.is_none() {
if kind == Kind::UnsubscribeAlarms
&& matches!(command.payload, Some(Payload::UnsubscribeAlarms(_)))
{
return Ok(reply);
}
match AlarmWorker::start(&options.session, max, publisher.clone()).await {
Ok(worker) => *alarm_worker = Some(worker),
Err(error) => {
set_status(
&mut reply,
ProtocolStatusCode::WorkerUnavailable,
&error.to_string(),
);
reply.hresult = None;
return Ok(reply);
}
}
}
let worker = alarm_worker.as_mut().expect("alarm worker was started");
return match worker
.invoke(&options.session, max, correlation, command)
.await
{
Ok(reply) => Ok(reply),
Err(error) => {
publisher.report_fault(EventFault::AlarmDisconnected);
set_status(
&mut reply,
ProtocolStatusCode::WorkerUnavailable,
&error.to_string(),
);
reply.hresult = None;
Ok(reply)
}
};
}
let native = match (kind, command.payload) { let native = match (kind, command.payload) {
(Kind::Register, Some(Payload::Register(request))) => { (Kind::Register, Some(Payload::Register(request))) => {
Command::Register(request.client_name) Command::Register(request.client_name)
@@ -463,6 +714,84 @@ async fn execute(
(Kind::AddItem, Some(Payload::AddItem(request))) => { (Kind::AddItem, Some(Payload::AddItem(request))) => {
Command::AddItem(request.server_handle, request.item_definition) Command::AddItem(request.server_handle, request.item_definition)
} }
(Kind::AddItem2, Some(Payload::AddItem2(request))) => Command::AddWithContext {
server: request.server_handle,
definition: request.item_definition,
context: request.item_context,
buffered: false,
},
(Kind::AddBufferedItem, Some(Payload::AddBufferedItem(request))) => {
Command::AddWithContext {
server: request.server_handle,
definition: request.item_definition,
context: request.item_context,
buffered: true,
}
}
(Kind::SetBufferedUpdateInterval, Some(Payload::SetBufferedUpdateInterval(request))) => {
Command::SetBufferedInterval(
request.server_handle,
request.update_interval_milliseconds,
)
}
(Kind::Suspend, Some(Payload::Suspend(request))) => Command::Activation {
server: request.server_handle,
item: request.item_handle,
active: false,
},
(Kind::Activate, Some(Payload::Activate(request))) => Command::Activation {
server: request.server_handle,
item: request.item_handle,
active: true,
},
(Kind::AuthenticateUser, Some(Payload::AuthenticateUser(request))) => {
Command::Authenticate(
request.server_handle,
request.verify_user,
request.verify_user_password,
)
}
(Kind::ArchestraUserToId, Some(Payload::ArchestraUserToId(request))) => {
Command::UserToId(request.server_handle, request.user_id_guid)
}
(Kind::AddItemBulk, Some(Payload::AddItemBulk(request))) => {
Command::SubscribeBulk(request.server_handle, request.tag_addresses, false)
}
(Kind::SubscribeBulk, Some(Payload::SubscribeBulk(request))) => {
Command::SubscribeBulk(request.server_handle, request.tag_addresses, true)
}
(Kind::AdviseItemBulk, Some(Payload::AdviseItemBulk(request))) => Command::ItemBulk(
request.server_handle,
request.item_handles,
ItemOperation::Advise,
),
(Kind::RemoveItemBulk, Some(Payload::RemoveItemBulk(request))) => Command::ItemBulk(
request.server_handle,
request.item_handles,
ItemOperation::Remove,
),
(Kind::UnAdviseItemBulk, Some(Payload::UnAdviseItemBulk(request))) => Command::ItemBulk(
request.server_handle,
request.item_handles,
ItemOperation::UnAdvise,
),
(Kind::UnsubscribeBulk, Some(Payload::UnsubscribeBulk(request))) => Command::ItemBulk(
request.server_handle,
request.item_handles,
ItemOperation::Unsubscribe,
),
(Kind::ReadBulk, Some(Payload::ReadBulk(request))) => {
let timeout = if request.timeout_ms == 0 {
1_000
} else {
request.timeout_ms
};
Command::ReadBulk(
request.server_handle,
request.tag_addresses,
Duration::from_millis(timeout.into()),
)
}
(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)
} }
@@ -609,12 +938,8 @@ async fn execute(
})); }));
return Ok(reply); return Ok(reply);
} }
(Kind::DrainEvents, payload @ (None | Some(Payload::DrainEvents(_)))) => { (Kind::DrainEvents, _) if drain.is_some() => {
let requested = match payload { reply.payload = drain.map(Reply::DrainEvents);
Some(Payload::DrainEvents(request)) => request.max_events,
_ => 0,
};
reply.payload = Some(Reply::DrainEvents(events.drain(requested, max)));
return Ok(reply); return Ok(reply);
} }
_ => { _ => {
@@ -638,7 +963,9 @@ async fn execute(
} }
match sta.execute(native).await.map_err(Error::sta)? { match sta.execute(native).await.map_err(Error::sta)? {
Ok(CommandResult::Handle(handle)) => { Ok(CommandResult::Handle(handle)) => {
if !matches!(kind, Kind::AuthenticateUser | Kind::ArchestraUserToId) {
reply.return_value = Some(int32(handle)); reply.return_value = Some(int32(handle));
}
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,
@@ -646,7 +973,45 @@ async fn execute(
Kind::AddItem => Reply::AddItem(AddItemReply { Kind::AddItem => Reply::AddItem(AddItemReply {
item_handle: handle, item_handle: handle,
}), }),
_ => unreachable!("only Register and AddItem return a handle"), Kind::AddItem2 => Reply::AddItem2(AddItem2Reply {
item_handle: handle,
}),
Kind::AddBufferedItem => Reply::AddBufferedItem(AddBufferedItemReply {
item_handle: handle,
}),
Kind::AuthenticateUser => {
Reply::AuthenticateUser(AuthenticateUserReply { user_id: handle })
}
Kind::ArchestraUserToId => {
Reply::ArchestraUserToId(ArchestrAUserToIdReply { user_id: handle })
}
_ => unreachable!("command has no integer result"),
});
}
Ok(CommandResult::Status(status)) => {
reply.payload = Some(match kind {
Kind::Suspend => Reply::Suspend(SuspendReply {
status: Some(status),
}),
Kind::Activate => Reply::Activate(ActivateReply {
status: Some(status),
}),
_ => unreachable!("command has no status result"),
});
}
Ok(CommandResult::ReadBulk(results)) => {
reply.payload = Some(Reply::ReadBulk(BulkReadReply { results }))
}
Ok(CommandResult::SubscribeBulk(results)) => {
let bulk = BulkSubscribeReply { results };
reply.payload = Some(match kind {
Kind::AddItemBulk => Reply::AddItemBulk(bulk),
Kind::AdviseItemBulk => Reply::AdviseItemBulk(bulk),
Kind::RemoveItemBulk => Reply::RemoveItemBulk(bulk),
Kind::UnAdviseItemBulk => Reply::UnAdviseItemBulk(bulk),
Kind::SubscribeBulk => Reply::SubscribeBulk(bulk),
Kind::UnsubscribeBulk => Reply::UnsubscribeBulk(bulk),
_ => unreachable!("command has no bulk subscription result"),
}); });
} }
Ok(CommandResult::Done) => {} Ok(CommandResult::Done) => {}
@@ -657,7 +1022,7 @@ async fn execute(
reply.statuses = statuses; reply.statuses = statuses;
} }
} }
events.publisher.discard_pending_write(); publisher.discard_pending_write();
} }
Ok(CommandResult::WriteBulk(results)) => { Ok(CommandResult::WriteBulk(results)) => {
let bulk = BulkWriteReply { results }; let bulk = BulkWriteReply { results };
@@ -673,9 +1038,10 @@ async fn execute(
set_status(&mut reply, ProtocolStatusCode::InvalidRequest, message); set_status(&mut reply, ProtocolStatusCode::InvalidRequest, message);
} }
Err(CommandError::NotRegistered) => { Err(CommandError::NotRegistered) => {
reply.hresult = Some(E_INVALIDARG);
set_status( set_status(
&mut reply, &mut reply,
ProtocolStatusCode::InvalidRequest, ProtocolStatusCode::MxaccessFailure,
"Server handle is not registered in this session", "Server handle is not registered in this session",
); );
} }
@@ -693,6 +1059,7 @@ struct EventStream {
receiver: mpsc::Receiver<MxEvent>, receiver: mpsc::Receiver<MxEvent>,
faults: watch::Receiver<Option<EventFault>>, faults: watch::Receiver<Option<EventFault>>,
pending: Option<MxEvent>, pending: Option<MxEvent>,
alarm_worker: Option<AlarmWorker>,
} }
impl EventStream { impl EventStream {
@@ -703,6 +1070,7 @@ impl EventStream {
receiver, receiver,
faults, faults,
pending: None, pending: None,
alarm_worker: None,
} }
} }
@@ -833,3 +1201,24 @@ fn now() -> Timestamp {
fn pid() -> i32 { fn pid() -> i32 {
std::process::id() as i32 std::process::id() as i32
} }
#[cfg(test)]
mod tests {
use super::PendingCommands;
#[test]
fn cancellation_only_marks_commands_that_have_not_started() {
let pending = PendingCommands::default();
pending.queue("running");
pending.queue("queued");
assert!(pending.begin("running"));
pending.cancel("running");
pending.cancel("queued");
assert_eq!(pending.count(), 1);
assert!(!pending.begin("queued"));
pending.queue("another");
pending.cancel_all();
assert!(!pending.begin("another"));
assert_eq!(pending.count(), 0);
}
}
@@ -55,11 +55,6 @@ async fn activates_registers_and_shuts_down_over_a_windows_pipe() {
pipe.connect().await.unwrap(); pipe.connect().await.unwrap();
let (mut reader, sender) = split(pipe); let (mut reader, sender) = split(pipe);
let mut writer = Writer::new(sender); let mut writer = Writer::new(sender);
let Body::WorkerHello(hello) = read_body(&mut reader, session).await else {
panic!("expected WorkerHello");
};
assert_eq!(hello.nonce, token);
assert_eq!(hello.worker_process_id, child.0.id() as i32);
writer writer
.send( .send(
session, session,
@@ -74,6 +69,11 @@ async fn activates_registers_and_shuts_down_over_a_windows_pipe() {
) )
.await .await
.unwrap(); .unwrap();
let Body::WorkerHello(hello) = read_body(&mut reader, session).await else {
panic!("expected WorkerHello");
};
assert_eq!(hello.nonce, token);
assert_eq!(hello.worker_process_id, child.0.id() as i32);
let ready = read_body(&mut reader, session).await; let ready = read_body(&mut reader, session).await;
let Body::WorkerReady(ready) = ready else { let Body::WorkerReady(ready) = ready else {
panic!("expected WorkerReady, got {ready:?}"); panic!("expected WorkerReady, got {ready:?}");
@@ -247,7 +247,7 @@ async fn invoke(
loop { loop {
let frame = wire::read(reader, session, 4096).await.unwrap(); let frame = wire::read(reader, session, 4096).await.unwrap();
match frame.body.unwrap() { match frame.body.unwrap() {
Body::WorkerHeartbeat(_) => {} Body::WorkerHeartbeat(_) | Body::WorkerEvent(_) => {}
Body::WorkerCommandReply(result) => { Body::WorkerCommandReply(result) => {
let reply = result.reply.unwrap(); let reply = result.reply.unwrap();
assert_eq!(frame.correlation_id, correlation); assert_eq!(frame.correlation_id, correlation);