From 9293c4c9138c0a584f743f06e6399a7096b9cb3a Mon Sep 17 00:00:00 2001 From: Joseph Doherty Date: Sat, 21 Nov 2026 09:53:37 -0500 Subject: [PATCH] Run alarm providers natively in the Rust worker --- .../WorkerLiveMxAccessSmokeTests.cs | 204 ++++- src/mxgateway-worker-rust/Cargo.lock | 53 +- src/mxgateway-worker-rust/Cargo.toml | 8 +- src/mxgateway-worker-rust/README.md | 45 +- src/mxgateway-worker-rust/src/alarm.rs | 761 +++++++++++------- src/mxgateway-worker-rust/src/alarm/ack.rs | 150 ++++ src/mxgateway-worker-rust/src/alarm/record.rs | 217 +++++ src/mxgateway-worker-rust/src/alarm/subtag.rs | 225 ++++++ src/mxgateway-worker-rust/src/alarm/wnwrap.rs | 203 +++++ src/mxgateway-worker-rust/src/automation.rs | 2 +- src/mxgateway-worker-rust/src/mxaccess.rs | 62 +- src/mxgateway-worker-rust/src/mxevent.rs | 38 +- src/mxgateway-worker-rust/src/session.rs | 100 +-- 13 files changed, 1638 insertions(+), 430 deletions(-) create mode 100644 src/mxgateway-worker-rust/src/alarm/ack.rs create mode 100644 src/mxgateway-worker-rust/src/alarm/record.rs create mode 100644 src/mxgateway-worker-rust/src/alarm/subtag.rs create mode 100644 src/mxgateway-worker-rust/src/alarm/wnwrap.rs diff --git a/src/ZB.MOM.WW.MxGateway.IntegrationTests/WorkerLiveMxAccessSmokeTests.cs b/src/ZB.MOM.WW.MxGateway.IntegrationTests/WorkerLiveMxAccessSmokeTests.cs index a0debd8a..4d029d74 100644 --- a/src/ZB.MOM.WW.MxGateway.IntegrationTests/WorkerLiveMxAccessSmokeTests.cs +++ b/src/ZB.MOM.WW.MxGateway.IntegrationTests/WorkerLiveMxAccessSmokeTests.cs @@ -10,10 +10,12 @@ using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Server.Kestrel.Core; using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Options; using ZB.MOM.WW.MxGateway.Contracts; using ZB.MOM.WW.MxGateway.Contracts.Proto; +using ZB.MOM.WW.MxGateway.Server.Alarms; using ZB.MOM.WW.MxGateway.Server.Configuration; using ZB.MOM.WW.MxGateway.Server.Grpc; using ZB.MOM.WW.MxGateway.Server.Metrics; @@ -597,7 +599,7 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output) } } - /// Verifies managed alarm provider callbacks forwarded by the Rust worker. + /// Verifies the Rust worker’s native subtag alarm provider and standby replacement. /// A task that represents the live test. [RustWorkerLiveFact] public async Task GatewayGrpc_WithRustWorker_ForwardsAlarmProviderCommandsAndEvents() @@ -738,13 +740,185 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output) } } - private static WebApplication BuildLoopbackGateway(MxAccessGatewayService service) + /// Raises a development Galaxy alarm and acknowledges it as an authenticated operator through gRPC. + /// A task that represents the live test. + [RustWorkerLiveFact] + public async Task GatewayGrpc_WithRustWorker_StreamsAndAcknowledgesNativeAlarm() + { + const string tag = "TestMachine_001.TestAlarm001"; + const string reference = "Galaxy!TestArea." + tag; + string user = Environment.GetEnvironmentVariable("MXGATEWAY_LIVE_MXACCESS_WRITE_SECURED_USER") ?? "Administrator"; + string password = Environment.GetEnvironmentVariable("MXGATEWAY_LIVE_MXACCESS_WRITE_SECURED_PASSWORD") ?? string.Empty; + string comment = $"Rust worker smoke {Guid.NewGuid():N}"; + string workerPath = IntegrationTestEnvironment.ResolveLiveMxAccessWorkerExecutablePath(); + await using GatewayServiceFixture fixture = new(workerPath, new TestWorkerProcessFactory(output), output, new AlarmsOptions + { + Enabled = true, + SubscriptionExpression = $@"\\{Environment.MachineName}\Galaxy!TestArea", + Fallback = new AlarmFallbackOptions { Mode = "Alarmmgr" }, + }); + await using WebApplication app = BuildLoopbackGateway(fixture.Service, fixture.Monitor); + using CancellationTokenSource deadline = new(TimeSpan.FromSeconds(85)); + CancellationToken token = deadline.Token; + await app.StartAsync(token).ConfigureAwait(false); + using GrpcChannel channel = GrpcChannel.ForAddress(app.Urls.Single()); + MxAccessGateway.MxAccessGatewayClient client = new(channel); + + using AsyncServerStreamingCall feed = client.StreamAlarms( + new StreamAlarmsRequest { AlarmFilterPrefix = reference }, cancellationToken: token); + bool snapshotComplete = false; + bool alarmmgrReady = false; + while ((!snapshotComplete || !alarmmgrReady) && await feed.ResponseStream.MoveNext(token).ConfigureAwait(false)) + { + AlarmFeedMessage frame = feed.ResponseStream.Current; + snapshotComplete |= frame.SnapshotComplete; + alarmmgrReady |= frame.ProviderStatus?.Mode == AlarmProviderMode.Alarmmgr; + } + Assert.True(snapshotComplete && alarmmgrReady, "The gateway did not open an Alarmmgr feed."); + + OpenSessionReply opened = await client.OpenSessionAsync(new OpenSessionRequest + { + ClientSessionName = "rust-native-alarm-driver", + }, cancellationToken: token).ResponseAsync.ConfigureAwait(false); + Assert.Equal(ProtocolStatusCode.Ok, opened.ProtocolStatus.Code); + string sessionId = opened.SessionId; + + async Task InvokeAsync(MxCommandRequest request, CancellationToken cancellationToken) + { + MxCommandReply reply = await client.InvokeAsync(request, deadline: DateTime.UtcNow.AddSeconds(15), + cancellationToken: cancellationToken).ResponseAsync.ConfigureAwait(false); + Assert.True(reply.ProtocolStatus.Code == ProtocolStatusCode.Ok, + $"{reply.Kind} returned {reply.ProtocolStatus.Code}: {reply.DiagnosticMessage}"); + return reply; + } + + async Task WaitForTransitionAsync(AlarmTransitionKind expected, string? ackComment = null) + { + while (await feed.ResponseStream.MoveNext(token).ConfigureAwait(false)) + { + OnAlarmTransitionEvent? transition = feed.ResponseStream.Current.Transition; + if (transition?.AlarmFullReference == reference && transition.TransitionKind == expected + && (ackComment is null || transition.OperatorComment == ackComment)) + { + Assert.Equal(AlarmProviderMode.Alarmmgr, transition.SourceProvider); + Assert.False(transition.Degraded); + return transition; + } + } + throw new InvalidOperationException($"Alarm stream ended before the {expected} transition."); + } + + MxCommandRequest? restore = null; + try + { + int server = (await InvokeAsync(CreateRegisterRequest(sessionId), token).ConfigureAwait(false)).Register.ServerHandle; + MxCommandReply read = await InvokeAsync(new MxCommandRequest + { + SessionId = sessionId, + Command = new MxCommand + { + Kind = MxCommandKind.ReadBulk, + ReadBulk = new ReadBulkCommand { ServerHandle = server, TimeoutMs = 5000, TagAddresses = { tag } }, + }, + }, token).ConfigureAwait(false); + BulkReadResult original = Assert.Single(read.ReadBulk.Results); + Assert.True(original.WasSuccessful, original.ErrorMessage); + Assert.Equal(MxValue.KindOneofCase.BoolValue, original.Value.KindCase); + MxCommandRequest add = CreateAddItemRequest(sessionId, server); + add.Command.AddItem.ItemDefinition = tag; + int item = (await InvokeAsync(add, token).ConfigureAwait(false)).AddItem.ItemHandle; + await InvokeAsync(CreateAdviseRequest(sessionId, server, item), token).ConfigureAwait(false); + int userId = (await InvokeAsync(CreateAuthenticateUserRequest(sessionId, server, user, password), token) + .ConfigureAwait(false)).AuthenticateUser.UserId; + Assert.NotEqual(0, userId); + + + MxCommandRequest WriteAlarm(bool active) + { + MxCommandRequest request = CreateWriteSecuredRequest(sessionId, server, item, userId, verifierUserId: 0); + request.Command.WriteSecured.Value = new MxValue { DataType = MxDataType.Boolean, BoolValue = active }; + return request; + } + + async Task WriteConfirmedAsync(MxCommandRequest request, CancellationToken cancellationToken) + { + MxCommandReply reply = await InvokeAsync(request, cancellationToken).ConfigureAwait(false); + Assert.NotEmpty(reply.Statuses); + Assert.All(reply.Statuses, status => Assert.Equal(MxStatusCategory.Ok, status.Category)); + } + + // The dev rig’s test UDA is normally false. Clear an existing test episode before raising a fresh one. + if (original.Value.BoolValue) + { + await WriteConfirmedAsync(WriteAlarm(false), token).ConfigureAwait(false); + restore = WriteAlarm(true); + await WaitForTransitionAsync(AlarmTransitionKind.Clear).ConfigureAwait(false); + } + await WriteConfirmedAsync(WriteAlarm(true), token).ConfigureAwait(false); + restore = WriteAlarm(original.Value.BoolValue); + await WaitForTransitionAsync(AlarmTransitionKind.Raise).ConfigureAwait(false); + + AcknowledgeAlarmReply rejected = await client.AcknowledgeAlarmAsync(new AcknowledgeAlarmRequest + { + AlarmFullReference = reference, + OperatorUser = $"mxgw-smoke-{Guid.NewGuid():N}", + Comment = "This acknowledgement must be rejected", + }, cancellationToken: token).ResponseAsync.ConfigureAwait(false); + Assert.Equal(ProtocolStatusCode.MxaccessFailure, rejected.ProtocolStatus.Code); + Assert.True(rejected.HasHresult && rejected.Hresult != 0); + + AcknowledgeAlarmReply ack = await client.AcknowledgeAlarmAsync(new AcknowledgeAlarmRequest + { + AlarmFullReference = reference, OperatorUser = user, OperatorPassword = password, Comment = comment, + }, cancellationToken: token).ResponseAsync.ConfigureAwait(false); + Assert.True(ack.ProtocolStatus.Code == ProtocolStatusCode.Ok, ack.DiagnosticMessage); + Assert.True(ack.HasHresult); + Assert.Equal(0, ack.Hresult); + Assert.DoesNotContain("unconfirmed", ack.DiagnosticMessage, StringComparison.OrdinalIgnoreCase); + Assert.DoesNotContain("not observed", ack.DiagnosticMessage, StringComparison.OrdinalIgnoreCase); + OnAlarmTransitionEvent acknowledged = await WaitForTransitionAsync(AlarmTransitionKind.Acknowledge, comment) + .ConfigureAwait(false); + Assert.Equal(user, acknowledged.OperatorUser, ignoreCase: true); + output.WriteLine($"Alarmmgr streamed Raise and Acknowledge with operator {acknowledged.OperatorUser} and the requested comment."); + + if (!original.Value.BoolValue) + { + await WriteConfirmedAsync(restore, token).ConfigureAwait(false); + restore = null; + await WaitForTransitionAsync(AlarmTransitionKind.Clear).ConfigureAwait(false); + output.WriteLine("The gateway streamed Clear after the test UDA was restored."); + } + } + finally + { + try + { + if (restore is not null) + { + MxCommandReply restored = await InvokeAsync(restore, CancellationToken.None).ConfigureAwait(false); + Assert.NotEmpty(restored.Statuses); + Assert.All(restored.Statuses, status => Assert.Equal(MxStatusCategory.Ok, status.Category)); + } + } + finally + { + await client.CloseSessionAsync(new CloseSessionRequest { SessionId = sessionId }, + deadline: DateTime.UtcNow.AddSeconds(25)).ResponseAsync.ConfigureAwait(false); + } + } + } + + private static WebApplication BuildLoopbackGateway(MxAccessGatewayService service, GatewayAlarmMonitor? monitor = null) { WebApplicationBuilder builder = WebApplication.CreateSlimBuilder(); builder.WebHost.ConfigureKestrel(options => options.Listen(IPAddress.Loopback, 0, listener => listener.Protocols = HttpProtocols.Http2)); builder.Services.AddGrpc(); builder.Services.AddSingleton(service); + if (monitor is not null) + { + builder.Services.AddSingleton(monitor); + } WebApplication app = builder.Build(); app.MapGrpcService(); return app; @@ -2732,12 +2906,14 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output) /// Path to the worker process executable. /// Factory for creating worker processes. /// Test output helper for logging. + /// Optional configuration for the central alarm monitor. public GatewayServiceFixture( string workerExecutablePath, IWorkerProcessFactory processFactory, - ITestOutputHelper output) + ITestOutputHelper output, + AlarmsOptions? alarms = null) { - IOptions options = Options.Create(CreateOptions(workerExecutablePath)); + IOptions options = Options.Create(CreateOptions(workerExecutablePath, alarms)); _loggerFactory = LoggerFactory.Create(builder => builder.AddProvider(new TestOutputLoggerProvider(output))); WorkerProcessLauncher launcher = new( options, @@ -2762,6 +2938,9 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output) options, _metrics); + Monitor = new GatewayAlarmMonitor( + sessionManager, EmptyAlarmWatchListResolver.Instance, _metrics, options, + _loggerFactory.CreateLogger()); Service = new MxAccessGatewayService( sessionManager, new GatewayRequestIdentityAccessor(), @@ -2771,12 +2950,7 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output) eventStreamService, _metrics, _loggerFactory.CreateLogger(), - new ZB.MOM.WW.MxGateway.Server.Alarms.GatewayAlarmMonitor( - sessionManager, - EmptyAlarmWatchListResolver.Instance, - _metrics, - options, - _loggerFactory.CreateLogger())); + Monitor); } /// @@ -2784,6 +2958,9 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output) /// public MxAccessGatewayService Service { get; } + /// The central alarm monitor for tests of the public alarm RPCs. + public GatewayAlarmMonitor Monitor { get; } + /// The manager used by the gateway's internal alarm monitor. public SessionManager Manager { get; } @@ -2807,19 +2984,22 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output) /// A task that represents the asynchronous operation. public async ValueTask DisposeAsync() { + await Monitor.StopAsync(CancellationToken.None).ConfigureAwait(false); foreach (GatewaySession session in _registry.Snapshot()) { await session.DisposeAsync().ConfigureAwait(false); } + Monitor.Dispose(); _loggerFactory.Dispose(); _metrics.Dispose(); } - private static GatewayOptions CreateOptions(string workerExecutablePath) + private static GatewayOptions CreateOptions(string workerExecutablePath, AlarmsOptions? alarms) { return new GatewayOptions { + Alarms = alarms ?? new AlarmsOptions(), Worker = new WorkerOptions { ExecutablePath = workerExecutablePath, @@ -2833,7 +3013,7 @@ public sealed class WorkerLiveMxAccessSmokeTests(ITestOutputHelper output) Sessions = new SessionOptions { DefaultCommandTimeoutSeconds = 15, - MaxSessions = 1, + MaxSessions = alarms?.Enabled == true ? 2 : 1, }, Events = new EventOptions { diff --git a/src/mxgateway-worker-rust/Cargo.lock b/src/mxgateway-worker-rust/Cargo.lock index 96e18adb..bc010bc3 100644 --- a/src/mxgateway-worker-rust/Cargo.lock +++ b/src/mxgateway-worker-rust/Cargo.lock @@ -17,6 +17,12 @@ version = "1.0.104" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + [[package]] name = "bitflags" version = "2.13.2" @@ -35,6 +41,15 @@ version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" +[[package]] +name = "chrono" +version = "0.4.45" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327" +dependencies = [ + "num-traits", +] + [[package]] name = "either" version = "1.19.0" @@ -156,13 +171,25 @@ checksum = "1d87ecb2933e8aeadb3e3a02b828fed80a7528047e68b4f424523a0981a3a084" name = "mxgateway-worker-rust" version = "0.1.0" dependencies = [ + "chrono", "prost", "prost-build", "prost-types", + "roxmltree", "tokio", + "uuid", "windows-sys", ] +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -300,6 +327,15 @@ version = "0.8.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d902046e6a28a1e4c3cab97258a0ce11e994903f01c2d97a9447a0b3df85f4f6" +[[package]] +name = "roxmltree" +version = "0.21.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9da7f59328b09405b181fee1018925fad50f157afb43c0c0f5c522c256dd5907" +dependencies = [ + "memchr", +] + [[package]] name = "rustix" version = "1.1.6" @@ -313,16 +349,6 @@ dependencies = [ "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]] name = "socket2" version = "0.6.5" @@ -378,7 +404,6 @@ dependencies = [ "libc", "mio", "pin-project-lite", - "signal-hook-registry", "socket2", "tokio-macros", "windows-sys", @@ -401,6 +426,12 @@ version = "1.0.27" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" +[[package]] +name = "uuid" +version = "1.29.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c14b15dffa2f4bd712103e857140aa04a4f2ff6e955c77d7eb8e53ee02a3b64" + [[package]] name = "wasi" version = "0.11.1+wasi-snapshot-preview1" diff --git a/src/mxgateway-worker-rust/Cargo.toml b/src/mxgateway-worker-rust/Cargo.toml index e1e2e1e0..5e7df6f1 100644 --- a/src/mxgateway-worker-rust/Cargo.toml +++ b/src/mxgateway-worker-rust/Cargo.toml @@ -10,16 +10,16 @@ prost-types = "0.13.5" tokio = { version = "1.48", features = ["io-util"] } [target.'cfg(windows)'.dependencies] -tokio = { version = "1.48", features = ["macros", "net", "process", "rt", "sync", "time"] } +tokio = { version = "1.48", features = ["macros", "net", "rt", "sync", "time"] } +chrono = { version = "0.4", default-features = false, features = ["std"] } +roxmltree = "0.21" +uuid = { version = "1", default-features = false } windows-sys = { version = "0.61", features = [ "Win32_Foundation", "Win32_Globalization", "Win32_Security", - "Win32_Security_Cryptography", "Win32_System_Com", - "Win32_System_JobObjects", "Win32_System_Ole", - "Win32_System_Pipes", "Win32_System_Threading", "Win32_System_Time", "Win32_System_Variant", diff --git a/src/mxgateway-worker-rust/README.md b/src/mxgateway-worker-rust/README.md index d500b363..7f7e6407 100644 --- a/src/mxgateway-worker-rust/README.md +++ b/src/mxgateway-worker-rust/README.md @@ -38,26 +38,20 @@ by MXAccess. The event also flows through StreamEvents. Bulk results report per-item COM acceptance and clients can observe commit outcomes on the event stream. -## Managed alarm provider +## Native 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 -``` +The Rust worker handles alarm subscription, active snapshots, standby watch-list +replacement, and authenticated acknowledgement in the worker process. It uses +the installed 32-bit AVEVA WnWrap COM alarm consumer for Alarmmgr and MXAccess +advice for the optional subtag fallback. The worker polls WnWrap on its COM +thread, emits changes on the existing event queue, and retains previously seen +records that a capped snapshot may have omitted. +To acknowledge a Galaxy alarm, the worker authenticates the operator with +MXAccess, writes the comment to the alarm's `AckMsg` attribute, and waits for +`OnWriteComplete` within the configured write-completion window. Deploy the +Rust executable on a Windows host with the System Platform COM components +registered. The Rust worker has no .NET worker companion. ## Build and test @@ -109,12 +103,17 @@ $env:MXGATEWAY_LIVE_MXACCESS_ITEM = 'TestChildObject.TestInt' 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. +The bulk and subtag tests use the deployed `TestChangingInt` items. The +Alarmmgr test raises `Galaxy!TestArea.TestMachine_001.TestAlarm001`, checks that +the gateway rejects an unknown operator, and verifies the authenticated +acknowledgement and its operator attribution on `StreamAlarms`. It restores the +test UDA afterward. The development rig uses `Administrator` with an empty +password. The test accepts credentials through +`MXGATEWAY_LIVE_MXACCESS_WRITE_SECURED_USER` and +`MXGATEWAY_LIVE_MXACCESS_WRITE_SECURED_PASSWORD`. ```powershell -dotnet test src/ZB.MOM.WW.MxGateway.IntegrationTests --filter 'FullyQualifiedName~GatewayGrpc_WithRustWorker_BulkItemsAndReads|FullyQualifiedName~GatewayGrpc_WithRustWorker_ForwardsAlarmProviderCommandsAndEvents' +dotnet test src/ZB.MOM.WW.MxGateway.IntegrationTests --filter 'FullyQualifiedName~GatewayGrpc_WithRustWorker_' ``` ## COM interface evidence @@ -137,3 +136,5 @@ the corresponding native calls and event callbacks. `ev_1b4fe7ab436437391b76f9fa3a300f45b58a4e1cff6aa84e30854f653c0a20df` - REA extended COM and buffered event member evidence `ev_39de39d626e3a933b259fa2650b42311ba60d6844d7b012284467284e8b82977` +- REA member evidence for the WnWrap v1 lifecycle and v2 XML snapshot interfaces + `ev_4fd97bf483b1cde2544b93a90f4de97569ea95c24f1eaa8aee49b5a1ed552558` diff --git a/src/mxgateway-worker-rust/src/alarm.rs b/src/mxgateway-worker-rust/src/alarm.rs index e9b3fc98..cc44560b 100644 --- a/src/mxgateway-worker-rust/src/alarm.rs +++ b/src/mxgateway-worker-rust/src/alarm.rs @@ -1,340 +1,507 @@ -//! 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. +mod ack; +mod record; +mod subtag; +mod wnwrap; -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 std::collections::BTreeMap; +use std::time::{Duration, Instant, SystemTime}; -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 uuid::Uuid; +use windows_sys::core::HRESULT; +use windows_sys::Win32::Foundation::E_FAIL; +use windows_sys::Win32::System::Threading::INFINITE; +use crate::mxaccess::{CommandError, CommandResult, Outcome, Proxy}; 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, +use crate::wire::mxaccess_gateway::v1::{ + mx_command::Payload, mx_command_reply::Payload as Reply, mx_event, + AcknowledgeAlarmReplyPayload, AlarmFailoverConfig, AlarmProviderMode as Mode, MxCommand, + MxCommandKind as Kind, MxCommandReply, MxEvent, MxEventFamily, OnAlarmProviderModeChangedEvent, + ProtocolStatus, ProtocolStatusCode as Code, QueryActiveAlarmsReplyPayload, + SubscribeAlarmsCommand, }; +use record::{parse_snapshot, Record, State}; +use subtag::Subtags; +use wnwrap::WnWrap; -const ALARM_WORKER_ENV: &str = "MXGATEWAY_RUST_ALARM_WORKER_EXE"; - -pub fn handles(kind: MxCommandKind) -> bool { +pub fn handles(kind: Kind) -> bool { matches!( kind, - MxCommandKind::SubscribeAlarms - | MxCommandKind::UnsubscribeAlarms - | MxCommandKind::UpdateAlarmWatchList - | MxCommandKind::QueryActiveAlarms - | MxCommandKind::AcknowledgeAlarm - | MxCommandKind::AcknowledgeAlarmByName + Kind::SubscribeAlarms + | Kind::UnsubscribeAlarms + | Kind::UpdateAlarmWatchList + | Kind::QueryActiveAlarms + | Kind::AcknowledgeAlarm + | Kind::AcknowledgeAlarmByName ) } -pub struct AlarmWorker { - child: Child, - _job: OwnedHandle, - writer: Writer>, - replies: mpsc::Receiver, - reader: JoinHandle<()>, - shutting_down: Arc, +struct AlarmError { + code: Code, + hr: Option, + message: String, } -impl AlarmWorker { - pub async fn start(session: &str, max: usize, publisher: Publisher) -> io::Result { - 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()); +impl AlarmError { + fn invalid(message: &str) -> Self { + Self { + code: Code::InvalidRequest, + hr: Some(-1), + message: message.into(), } + } - 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()); + fn failed(step: &str, hr: HRESULT) -> Self { + Self { + code: Code::MxaccessFailure, + hr: Some(hr), + message: format!("{step} failed (HRESULT 0x{:08X})", hr as u32), + } + } + + fn unavailable(message: &str) -> Self { + Self { + code: Code::MxaccessFailure, + hr: None, + message: message.into(), + } + } + + fn com(step: &str, error: CommandError) -> Self { + Self::failed( + step, + match error { + CommandError::HResult(hr) => hr, + _ => E_FAIL, + }, + ) + } +} + +fn handle(result: Outcome, step: &str) -> Result { + match result.map_err(|error| AlarmError::com(step, error))? { + CommandResult::Handle(value) => Ok(value), + _ => unreachable!("handle-returning command"), + } +} + +struct Primary { + expression: String, + consumer: Option, + records: BTreeMap, + truncated: bool, +} + +impl Primary { + fn poll(&mut self, proxy: &Proxy, limit: i32, emit: bool) -> Result<(), HRESULT> { + if self.consumer.is_none() { + self.consumer = Some(WnWrap::subscribe(&self.expression)?); + } + let xml = self.consumer.as_ref().unwrap().snapshot(limit)?; + if xml.is_empty() { + return Ok(()); + } + let (records, count) = parse_snapshot(&xml).map_err(|_| E_FAIL)?; + let previous = std::mem::replace(&mut self.records, records); + self.truncated = count >= limit as usize; + if emit { + for (&id, record) in &self.records { + let prior = previous + .get(&id) + .map_or(State::Unknown, |record| record.state); + publish_record(&proxy.publisher, record, prior, Mode::Alarmmgr); } - if connected_pid != pid { - return Err(invalid( - "Unexpected process connected to the alarm worker pipe", - )); + } + if self.truncated { + for (id, record) in previous { + self.records.entry(id).or_insert(record); } - 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")), + } + Ok(()) + } +} + +struct Subscription { + mode: Mode, + primary: Option, + subtags: Option, + automatic: bool, + next_probe: Instant, + failures: i32, + stable_probes: i32, + settings: AlarmFailoverConfig, +} + +pub struct AlarmRuntime { + subscription: Option, + interval: Duration, + next_poll: Instant, + limit: i32, +} + +impl AlarmRuntime { + pub fn new() -> Self { + Self { + subscription: None, + interval: Duration::from_millis(setting( + "MXGATEWAY_ALARM_POLL_INTERVAL_MS", + 500, + 100..=3_600_000, + ) as u64), + next_poll: Instant::now(), + limit: setting("MXGATEWAY_ALARM_MAX_ALARMS_PER_FETCH", 1024, 64..=65_536), + } + } + + pub fn wait_millis(&self) -> u32 { + if self.subscription.is_none() { + return INFINITE; + } + let remaining = self.next_poll.saturating_duration_since(Instant::now()); + remaining.as_nanos().div_ceil(1_000_000) as u32 + } + + pub fn close(&mut self, proxy: &mut Proxy) { + if let Some(mut subscription) = self.subscription.take() { + if let Some(subtags) = &mut subscription.subtags { + subtags.close(proxy); } - 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)) + } + } + + pub fn poll(&mut self, proxy: &Proxy) { + let Some(subscription) = &mut self.subscription else { + return; + }; + if let Some(subtags) = &mut subscription.subtags { + subtags.drain(proxy, subscription.mode == Mode::Subtag); + } + let now = Instant::now(); + if now < self.next_poll { + return; + } + self.next_poll = now + self.interval; + let Some(primary) = &mut subscription.primary else { + return; + }; + let probe_interval = + Duration::from_secs(subscription.settings.failback_probe_interval_seconds as u64); + match subscription.mode { + Mode::Alarmmgr => match primary.poll(proxy, self.limit, true) { + Ok(()) => subscription.failures = 0, + Err(hr) if subscription.automatic => { + subscription.failures += 1; + if subscription.failures >= subscription.settings.consecutive_failure_threshold + { + subscription.mode = Mode::Subtag; + subscription.next_probe = now + probe_interval; + subscription.stable_probes = 0; + publish_mode(&proxy.publisher, Mode::Subtag, "primary poll failed", hr); + } + } + Err(hr) => { + subscription.failures += 1; + if subscription.failures >= 3 { + proxy.publisher.report_fault(EventFault::AlarmPoll(hr)); + } + } + }, + Mode::Subtag if now >= subscription.next_probe => { + subscription.next_probe = now + probe_interval; + if primary.poll(proxy, self.limit, false).is_ok() { + subscription.stable_probes += 1; + if subscription.stable_probes >= subscription.settings.failback_stable_probes { + subscription.mode = Mode::Alarmmgr; + subscription.failures = 0; + publish_mode(&proxy.publisher, Mode::Alarmmgr, "recovered", 0); + } + } else { + subscription.stable_probes = 0; } - _ => 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()); + fn subscribe( + &mut self, + proxy: &mut Proxy, + request: SubscribeAlarmsCommand, + ) -> Result<(), AlarmError> { + if self.subscription.is_some() { + return Err(AlarmError::unavailable( + "Alarm provider is already subscribed", + )); + } + let mode = Mode::try_from(request.forced_mode) + .map_err(|_| AlarmError::invalid("Invalid alarm provider mode"))?; + if request.subscription_expression.trim().is_empty() + || request.subscription_expression.contains('\0') + { + return Err(AlarmError::invalid( + "A valid alarm subscription expression is required", + )); + } + let automatic = mode == Mode::Unspecified + && (request.fallback_enabled || !request.watch_list.is_empty()); + let settings = request.failover.unwrap_or(AlarmFailoverConfig { + consecutive_failure_threshold: 3, + failback_probe_interval_seconds: 30, + failback_stable_probes: 3, + }); + if automatic + && (settings.consecutive_failure_threshold < 1 + || settings.failback_probe_interval_seconds < 1 + || settings.failback_stable_probes < 1) + { + return Err(AlarmError::invalid( + "Alarm failover settings must be positive", + )); + } + let mut subscription = Subscription { + mode: if mode == Mode::Subtag { + Mode::Subtag + } else { + Mode::Alarmmgr + }, + primary: (mode != Mode::Subtag).then(|| Primary { + expression: request.subscription_expression, + consumer: None, + records: BTreeMap::new(), + truncated: false, + }), + subtags: None, + automatic, + next_probe: Instant::now(), + failures: 0, + stable_probes: 0, + settings, + }; + let mut initial_failure = None; + if let Some(primary) = &mut subscription.primary { + match WnWrap::subscribe(&primary.expression) { + Ok(consumer) => primary.consumer = Some(consumer), + Err(hr) if automatic => { + subscription.failures = 1; + initial_failure = Some(hr); + } + Err(hr) => return Err(AlarmError::failed("WnWrap subscribe", hr)), + } + } + if automatic || mode == Mode::Subtag { + subscription.subtags = Some(Subtags::attach(proxy, request.watch_list)?); + } + if let Some(hr) = + initial_failure.filter(|_| subscription.settings.consecutive_failure_threshold == 1) + { + subscription.mode = Mode::Subtag; + subscription.next_probe = Instant::now() + + Duration::from_secs(subscription.settings.failback_probe_interval_seconds as u64); + publish_mode( + &proxy.publisher, + Mode::Subtag, + "primary subscribe failed", + hr, + ); + } + self.subscription = Some(subscription); + self.next_poll = Instant::now(); + Ok(()) + } + + pub fn execute(&mut self, proxy: &mut Proxy, command: MxCommand) -> MxCommandReply { + let mut reply = MxCommandReply { + kind: command.kind, + hresult: Some(0), + ..Default::default() + }; + let result = self.dispatch(proxy, command, &mut reply); + let (code, message) = match result { + Ok(()) => (Code::Ok, std::mem::take(&mut reply.diagnostic_message)), + Err(error) => { + reply.hresult = error.hr; + if matches!( + reply.kind(), + Kind::AcknowledgeAlarm | Kind::AcknowledgeAlarmByName + ) { + reply.payload = Some(Reply::AcknowledgeAlarm(AcknowledgeAlarmReplyPayload { + native_status: error.hr.unwrap_or(-1), + })); + } + (error.code, error.message) + } + }; + reply.protocol_status = Some(ProtocolStatus { + code: code as i32, + message: message.clone(), + }); + reply.diagnostic_message = message; + reply + } + + fn dispatch( + &mut self, + proxy: &mut Proxy, + command: MxCommand, + reply: &mut MxCommandReply, + ) -> Result<(), AlarmError> { + match (command.kind(), command.payload) { + (Kind::SubscribeAlarms, Some(Payload::SubscribeAlarms(request))) => { + self.subscribe(proxy, request) + } + (Kind::UnsubscribeAlarms, Some(Payload::UnsubscribeAlarms(_))) => { + self.close(proxy); + Ok(()) + } + (Kind::UpdateAlarmWatchList, Some(Payload::UpdateAlarmWatchList(request))) => { + let subscription = self.subscription.as_mut().filter(|subscription| subscription.automatic) + .ok_or_else(|| AlarmError::unavailable("Alarm watch list replacement requires an automatic fallback subscription"))?; + let replacement = Subtags::attach(proxy, request.watch_list)?; + if let Some(mut old) = subscription.subtags.replace(replacement) { + old.close(proxy); + } + Ok(()) + } + (Kind::QueryActiveAlarms, Some(Payload::QueryActiveAlarmsCommand(request))) => { + let subscription = self + .subscription + .as_ref() + .ok_or_else(|| AlarmError::unavailable("Alarm provider is not subscribed"))?; + let mut result = QueryActiveAlarmsReplyPayload::default(); + { + let mut append = |record: &Record, truncated| { + if record.state.active() + && record.reference().starts_with(&request.alarm_filter_prefix) + { + result + .snapshots + .push(record.snapshot(subscription.mode, truncated)); + } + }; + if subscription.mode == Mode::Subtag { + if let Some(subtags) = &subscription.subtags { + for record in subtags.records() { + append(record, false); } } - } - Some(Body::WorkerHeartbeat(_)) => {} - Some(Body::WorkerCommandReply(_) | Body::WorkerShutdownAck(_)) => { - if incoming.send(frame).await.is_err() { - break; + } else if let Some(primary) = &subscription.primary { + for record in primary.records.values() { + append(record, primary.truncated); } + result.snapshot_truncated = primary.truncated; } - _ => break, } + reply.payload = Some(Reply::QueryActiveAlarms(result)); + Ok(()) } - if !closing.load(Ordering::Acquire) { - publisher.report_fault(EventFault::AlarmDisconnected); + (Kind::AcknowledgeAlarm, Some(Payload::AcknowledgeAlarmCommand(request))) => { + let id = Uuid::parse_str(&request.alarm_guid) + .map_err(|_| AlarmError::invalid("Invalid alarm GUID"))?; + let address = self.ack_address(Some(id), None)?; + ack::acknowledge( + proxy, + address, + request.operator_user, + request.operator_domain, + request.operator_password, + request.comment, + reply, + ) } - }); - 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 { - 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")) + ( + Kind::AcknowledgeAlarmByName, + Some(Payload::AcknowledgeAlarmByNameCommand(request)), + ) => { + let address = self.ack_address( + None, + Some(( + &request.provider_name, + &request.group_name, + &request.alarm_name, + )), + )?; + ack::acknowledge( + proxy, + address, + request.operator_user, + request.operator_domain, + request.operator_password, + request.comment, + reply, + ) } - _ => Err(invalid("Alarm worker sent an unexpected response")), + _ => Err(AlarmError::invalid( + "Alarm command payload does not match its kind", + )), } } - pub async fn shutdown( - mut self, - session: &str, - max: usize, - grace: Duration, - ) -> io::Result { - 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, + fn ack_address( + &self, + id: Option, + name: Option<(&str, &str, &str)>, + ) -> Result { + let subscription = self + .subscription + .as_ref() + .ok_or_else(|| AlarmError::invalid("Alarm provider is not subscribed"))?; + let not_found = + || AlarmError::invalid("Alarm was not found or does not support acknowledgement"); + if subscription.mode == Mode::Subtag { + let subtags = subscription.subtags.as_ref().ok_or_else(not_found)?; + let address = if let Some(id) = id { + subtags.ack_address(id) + } else if let Some((provider, group, name)) = name { + let reference = record::full_reference(provider, group, name); + subtags.ack_address_by_reference(&reference) + } else { + None + }; + return address.map(str::to_owned).ok_or_else(not_found); + } + let (provider, name) = if let Some(id) = id { + let record = subscription + .primary + .as_ref() + .and_then(|primary| primary.records.get(&id)) + .ok_or_else(not_found)?; + (record.provider.as_str(), record.name.as_str()) + } else { + let (provider, _, name) = name.ok_or_else(not_found)?; + (provider, name) }; - if !self.child.wait().await?.success() { - failures += 1; + if !provider.eq_ignore_ascii_case("Galaxy") || name.trim().is_empty() { + return Err(not_found()); } - Ok(failures) + Ok(format!("{name}.AckMsg")) } } -impl Drop for AlarmWorker { - fn drop(&mut self) { - self.shutting_down.store(true, Ordering::Release); - self.reader.abort(); - } +fn setting(name: &str, default: i32, range: std::ops::RangeInclusive) -> i32 { + std::env::var(name) + .ok() + .and_then(|value| value.parse().ok()) + .filter(|value| range.contains(value)) + .unwrap_or(default) } -fn alarm_executable() -> io::Result { - 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 publish_mode(publisher: &Publisher, mode: Mode, reason: &str, hr: HRESULT) { + publisher.publish(MxEvent { + family: MxEventFamily::OnAlarmProviderModeChanged as i32, + body: Some(mx_event::Body::OnAlarmProviderModeChanged( + OnAlarmProviderModeChangedEvent { + mode: mode as i32, + reason: reason.into(), + hresult: hr, + at: Some(SystemTime::now().into()), + }, + )), + ..Default::default() + }); } -fn random_token() -> io::Result { - 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", - )); +fn publish_record(publisher: &Publisher, record: &Record, previous: State, mode: Mode) { + if let Some(event) = record.event(previous, mode) { + publisher.publish(event); } - Ok(bytes.iter().map(|byte| format!("{byte:02x}")).collect()) -} - -fn kill_on_close_job() -> io::Result { - // 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::() 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", - ) } diff --git a/src/mxgateway-worker-rust/src/alarm/ack.rs b/src/mxgateway-worker-rust/src/alarm/ack.rs new file mode 100644 index 00000000..abb37131 --- /dev/null +++ b/src/mxgateway-worker-rust/src/alarm/ack.rs @@ -0,0 +1,150 @@ +use std::time::Instant; + +use tokio::sync::oneshot::error::TryRecvError; +use windows_sys::Win32::Foundation::{E_FAIL, WAIT_OBJECT_0, WAIT_TIMEOUT}; +use windows_sys::Win32::UI::WindowsAndMessaging::{ + MsgWaitForMultipleObjectsEx, MWMO_INPUTAVAILABLE, QS_ALLINPUT, +}; + +use super::{handle, AlarmError}; +use crate::mxaccess::{pump_messages, Command, CommandResult, Proxy, WriteAccess, WriteRequest}; +use crate::mxevent::WriteCompletion; +use crate::wire::mxaccess_gateway::v1::{ + mx_command_reply::Payload as Reply, mx_value, AcknowledgeAlarmReplyPayload, MxCommandReply, + MxDataType, MxStatusCategory, MxValue, ProtocolStatusCode as Code, +}; + +pub(super) fn acknowledge( + proxy: &mut Proxy, + address: String, + user: String, + domain: String, + password: String, + comment: String, + reply: &mut MxCommandReply, +) -> Result<(), AlarmError> { + if user.trim().is_empty() { + return Err(AlarmError::invalid("Alarm operator user is required")); + } + let principal = if domain.is_empty() { + user + } else { + format!("{domain}\\{user}") + }; + let client = std::env::var("MXGATEWAY_ALARM_ACK_CLIENT_NAME").unwrap_or_default(); + let client = match client.trim() { + "" => "MxGateway", + name => name, + }; + let server = handle( + proxy.execute(Command::Register(client.into())), + "Register alarm acknowledgement", + )?; + proxy.publisher.private_registration(server, false); + let result = (|| { + let user = handle( + proxy.execute(Command::Authenticate(server, principal, password)), + "Alarm operator authentication", + )?; + if user == 0 { + return Err(AlarmError::failed( + "Alarm operator authentication (no user id)", + -1, + )); + } + let item = handle( + proxy.execute(Command::AddItem(server, address)), + "Add AckMsg item", + )?; + proxy + .execute(Command::Advise { + server, + item, + supervisory: false, + }) + .map_err(|error| AlarmError::com("Advise AckMsg item", error))?; + if !pump_messages() { + return Err(AlarmError::failed("AckMsg message pump", E_FAIL)); + } + let value = MxValue { + data_type: MxDataType::String as i32, + kind: Some(mx_value::Kind::StringValue(comment)), + ..Default::default() + }; + let CommandResult::Write(completion) = proxy + .execute(Command::Write(Box::new(WriteRequest { + server, + item, + value: Some(value), + timestamp: None, + access: WriteAccess::Plain(user), + }))) + .map_err(|error| AlarmError::com("AckMsg write", error))? + else { + unreachable!("write command returns a completion"); + }; + complete_ack(completion, reply) + })(); + proxy.publisher.discard_pending_write(); + let _ = proxy.execute(Command::Unregister(server)); + result +} + +fn complete_ack( + mut completion: WriteCompletion, + reply: &mut MxCommandReply, +) -> Result<(), AlarmError> { + let wait = crate::mxaccess::write_completion_wait(); + let deadline = Instant::now() + wait; + loop { + match completion.try_recv() { + Ok(statuses) => { + if let Some(status) = statuses + .iter() + .find(|status| status.category() != MxStatusCategory::Ok) + { + return Err(AlarmError { + code: Code::MxaccessFailure, + hr: Some(status.detail), + message: format!( + "AckMsg write rejected (category {}, detail {})", + status.category, status.detail + ), + }); + } + break; + } + Err(TryRecvError::Closed) => { + return Err(AlarmError::failed("AckMsg completion channel", E_FAIL)) + } + Err(TryRecvError::Empty) => {} + } + let remaining = deadline.saturating_duration_since(Instant::now()); + if remaining.is_zero() { + reply.diagnostic_message = format!( + "AckMsg write sent; OnWriteComplete not observed within {} ms", + wait.as_millis() + ); + break; + } + // SAFETY: waits only on the current STA's queue. + let result = unsafe { + MsgWaitForMultipleObjectsEx( + 0, + std::ptr::null(), + remaining.as_nanos().div_ceil(1_000_000) as u32, + QS_ALLINPUT, + MWMO_INPUTAVAILABLE, + ) + }; + match result { + WAIT_TIMEOUT => {} + WAIT_OBJECT_0 if pump_messages() => {} + _ => return Err(AlarmError::failed("AckMsg message pump", E_FAIL)), + } + } + reply.payload = Some(Reply::AcknowledgeAlarm(AcknowledgeAlarmReplyPayload { + native_status: 0, + })); + Ok(()) +} diff --git a/src/mxgateway-worker-rust/src/alarm/record.rs b/src/mxgateway-worker-rust/src/alarm/record.rs new file mode 100644 index 00000000..856231cf --- /dev/null +++ b/src/mxgateway-worker-rust/src/alarm/record.rs @@ -0,0 +1,217 @@ +use std::collections::BTreeMap; + +use chrono::{NaiveDate, NaiveTime}; +use prost_types::Timestamp; +use uuid::Uuid; + +use crate::wire::mxaccess_gateway::v1::{ + mx_event, ActiveAlarmSnapshot, AlarmConditionState, AlarmProviderMode, AlarmTransitionKind, + MxEvent, MxEventFamily, OnAlarmTransitionEvent, +}; + +#[derive(Clone, Copy, Default, PartialEq, Eq)] +pub enum State { + #[default] + Unknown, + Active, + ActiveAcked, + Returned, + ReturnedAcked, +} + +impl State { + pub fn active(self) -> bool { + matches!(self, Self::Active | Self::ActiveAcked) + } + + fn returned(self) -> bool { + matches!(self, Self::Returned | Self::ReturnedAcked) + } + + fn acked(self) -> bool { + matches!(self, Self::ActiveAcked | Self::ReturnedAcked) + } + + fn transition(self, previous: Self) -> Option { + use AlarmTransitionKind::{Acknowledge, Clear, Raise}; + match self { + Self::Unknown => None, + _ if previous == Self::Unknown => Some(if self.active() { Raise } else { Clear }), + _ if previous.active() && self.returned() => Some(Clear), + _ if previous.returned() && self.active() => Some(Raise), + _ if !previous.acked() && self.acked() => Some(Acknowledge), + _ => None, + } + } +} + +#[derive(Default)] +pub struct Record { + pub provider: String, + pub group: String, + pub name: String, + pub alarm_type: String, + pub priority: i32, + pub state: State, + pub at: Option, + pub operator: String, + pub comment: String, + pub ack_operator: String, + pub ack_comment: String, +} + +impl Record { + pub fn reference(&self) -> String { + full_reference(&self.provider, &self.group, &self.name) + } + + pub fn event(&self, previous: State, mode: AlarmProviderMode) -> Option { + let transition = self.state.transition(previous)?; + let (operator_user, operator_comment) = + self.attribution(transition == AlarmTransitionKind::Acknowledge); + let body = OnAlarmTransitionEvent { + alarm_full_reference: self.reference(), + source_object_reference: self.name.clone(), + alarm_type_name: self.alarm_type.clone(), + transition_kind: transition as i32, + severity: self.priority, + transition_timestamp: self.at.or(Some(Timestamp { + seconds: -62_135_596_800, + nanos: 0, + })), + operator_user, + operator_comment, + category: self.group.clone(), + degraded: mode == AlarmProviderMode::Subtag, + source_provider: mode as i32, + ..Default::default() + }; + Some(MxEvent { + family: MxEventFamily::OnAlarmTransition as i32, + body: Some(mx_event::Body::OnAlarmTransition(body)), + ..Default::default() + }) + } + + pub fn snapshot(&self, mode: AlarmProviderMode, truncated: bool) -> ActiveAlarmSnapshot { + let (operator_user, operator_comment) = self.attribution(self.state.acked()); + ActiveAlarmSnapshot { + alarm_full_reference: self.reference(), + source_object_reference: self.name.clone(), + alarm_type_name: self.alarm_type.clone(), + severity: self.priority, + current_state: if self.state.acked() { + AlarmConditionState::ActiveAcked + } else { + AlarmConditionState::Active + } as i32, + last_transition_timestamp: self.at, + operator_user, + operator_comment, + category: self.group.clone(), + degraded: mode == AlarmProviderMode::Subtag, + source_provider: mode as i32, + from_truncated_snapshot: truncated, + ..Default::default() + } + } + + fn attribution(&self, ack: bool) -> (String, String) { + if ack && (!self.ack_operator.is_empty() || !self.ack_comment.is_empty()) { + (self.ack_operator.clone(), self.ack_comment.clone()) + } else { + (self.operator.clone(), self.comment.clone()) + } + } +} + +pub fn full_reference(provider: &str, group: &str, name: &str) -> String { + let separator = if provider.is_empty() { "" } else { "!" }; + let dot = if group.is_empty() { "" } else { "." }; + format!("{provider}{separator}{group}{dot}{name}") +} + +pub fn parse_snapshot(xml: &str) -> Result<(BTreeMap, usize), roxmltree::Error> { + let mut records = BTreeMap::new(); + if xml.trim().is_empty() { + return Ok((records, 0)); + } + let document = roxmltree::Document::parse(xml)?; + let root = document.root_element(); + if !unqualified(root, "ALARM_RECORDS") { + return Ok((records, 0)); + } + + let mut count = 0; + for alarm in root.children().filter(|&child| unqualified(child, "ALARM")) { + count += 1; + let mut fields = BTreeMap::new(); + for field in alarm.children().filter(roxmltree::Node::is_element) { + fields.entry(field.tag_name().name()).or_insert_with(|| { + field + .descendants() + .filter(roxmltree::Node::is_text) + .filter_map(|node| node.text()) + .collect::() + }); + } + let field = |name| fields.get(name).map_or("", String::as_str); + let Ok(id) = Uuid::parse_str(field("GUID").trim()) else { + continue; + }; + records.insert( + id, + Record { + provider: field("PROVIDER_NAME").into(), + group: field("GROUP").into(), + name: field("TAGNAME").into(), + alarm_type: field("TYPE").into(), + priority: field("PRIORITY").trim().parse().unwrap_or_default(), + state: match field("STATE").trim().to_ascii_uppercase().as_str() { + "UNACK_ALM" => State::Active, + "ACK_ALM" => State::ActiveAcked, + "UNACK_RTN" => State::Returned, + "ACK_RTN" => State::ReturnedAcked, + _ => State::Unknown, + }, + at: parse_timestamp(field("DATE"), field("TIME")), + operator: field("OPERATOR_NAME").into(), + comment: field("ALARM_COMMENT").into(), + ack_operator: field("ACK_OPERATOR_NAME").into(), + ack_comment: field("ACK_COMMENT").into(), + }, + ); + } + Ok((records, count)) +} + +fn unqualified(node: roxmltree::Node<'_, '_>, name: &str) -> bool { + node.is_element() && node.tag_name().namespace().is_none() && node.tag_name().name() == name +} + +fn parse_timestamp(date: &str, time: &str) -> Option { + let date = ["%Y/%m/%d", "%m/%d/%Y", "%d/%m/%Y"] + .into_iter() + .find_map(|format| NaiveDate::parse_from_str(date.trim(), format).ok())?; + let time = NaiveTime::parse_from_str(time.trim(), "%H:%M:%S%.f").ok()?; + let timestamp = date.and_time(time).and_utc(); + Some(Timestamp { + seconds: timestamp.timestamp(), + nanos: timestamp.timestamp_subsec_nanos() as i32, + }) +} + +pub fn synthetic_guid(reference: &str) -> Uuid { + const PRIME: u64 = 1_099_511_628_211; + let mut low = 14_695_981_039_346_656_037_u64; + let mut high = 1_469_598_103_934_665_603_u64; + for (index, byte) in reference.bytes().enumerate() { + low = (low ^ u64::from(byte)).wrapping_mul(PRIME); + high = (high ^ (u64::from(byte) + index as u64)).wrapping_mul(PRIME); + } + low = (low ^ reference.len() as u64).wrapping_mul(PRIME); + let mut bytes = [0; 16]; + bytes[..8].copy_from_slice(&low.to_le_bytes()); + bytes[8..].copy_from_slice(&high.to_le_bytes()); + Uuid::from_bytes_le(bytes) +} diff --git a/src/mxgateway-worker-rust/src/alarm/subtag.rs b/src/mxgateway-worker-rust/src/alarm/subtag.rs new file mode 100644 index 00000000..9013f925 --- /dev/null +++ b/src/mxgateway-worker-rust/src/alarm/subtag.rs @@ -0,0 +1,225 @@ +use std::collections::{BTreeMap, BTreeSet}; + +use uuid::Uuid; + +use super::record::{synthetic_guid, Record, State}; +use super::{handle, AlarmError}; +use crate::mxaccess::{Command, Proxy}; +use crate::wire::mxaccess_gateway::v1::{ + mx_value::Kind as Value, AlarmProviderMode, AlarmSubtagTarget, +}; + +#[derive(Clone, Copy)] +enum Role { + Active, + Acked, + Priority, +} + +struct Target { + config: AlarmSubtagTarget, + record: Record, + acked_during_episode: bool, +} + +pub struct Subtags { + server: Option, + items: BTreeMap, + targets: BTreeMap, +} + +impl Subtags { + pub fn attach(proxy: &mut Proxy, configs: Vec) -> Result { + let mut targets = BTreeMap::new(); + let mut references = BTreeSet::new(); + let mut addresses = BTreeSet::new(); + let mut bindings = Vec::new(); + for config in configs { + let reference = &config.alarm_full_reference; + if reference.trim().is_empty() || !references.insert(reference.to_lowercase()) { + return Err(AlarmError::invalid( + "Alarm watch list has an empty or duplicate reference", + )); + } + let id = synthetic_guid(reference); + for (address, role) in [ + (&config.active_subtag, Role::Active), + (&config.acked_subtag, Role::Acked), + (&config.priority_subtag, Role::Priority), + ] { + if address.trim().is_empty() { + continue; + } + if !addresses.insert(address.to_lowercase()) { + return Err(AlarmError::invalid( + "Alarm watch list has a duplicate subtag address", + )); + } + bindings.push((address.clone(), id, role)); + } + let (provider, path) = reference.split_once('!').unwrap_or(("", reference)); + let mut offset = 0; + let mut group_and_name = ("", path); + for segment in path.split('.') { + if segment.eq_ignore_ascii_case(&config.source_object_reference) { + if offset > 0 { + group_and_name = (&path[..offset - 1], &path[offset..]); + } + break; + } + offset += segment.len() + 1; + } + let (group, name) = group_and_name; + let record = Record { + provider: provider.into(), + group: group.into(), + name: name.into(), + ..Default::default() + }; + targets.insert( + id, + Target { + config, + record, + acked_during_episode: false, + }, + ); + } + + let mut subtags = Self { + server: None, + items: BTreeMap::new(), + targets, + }; + if !bindings.is_empty() { + let server = handle( + proxy.execute(Command::Register( + "OtOpcUa.ZB.MOM.WW.MxGateway.Worker.SubtagAlarms".into(), + )), + "Register alarm subtags", + )?; + proxy.publisher.private_registration(server, true); + subtags.server = Some(server); + for (address, id, role) in bindings { + let result = (|| { + let item = handle( + proxy.execute(Command::AddItem(server, address)), + "Add alarm subtag", + )?; + proxy + .execute(Command::Advise { + server, + item, + supervisory: false, + }) + .map_err(|error| AlarmError::com("Advise alarm subtag", error))?; + subtags.items.insert(item, (id, role)); + Ok(()) + })(); + if let Err(error) = result { + subtags.close(proxy); + return Err(error); + } + } + } + Ok(subtags) + } + + pub fn close(&mut self, proxy: &mut Proxy) { + if let Some(server) = self.server.take() { + let _ = proxy.execute(Command::Unregister(server)); + } + } + + pub fn drain(&mut self, proxy: &Proxy, emit: bool) { + let Some(server) = self.server else { + return; + }; + for event in proxy.publisher.private_events(server) { + let Some(&(id, role)) = self.items.get(&event.item_handle) else { + continue; + }; + let target = self.targets.get_mut(&id).expect("binding has a target"); + let record = &mut target.record; + let previous = record.state; + let value = event.value.and_then(|value| value.kind); + let number = numeric(value.as_ref()); + let flag = number.is_some_and(|number| number != 0.0); + record.state = match role { + Role::Priority => { + if let Some(priority) = number + .map(f64::round_ties_even) + .filter(|value| (i32::MIN as f64..=i32::MAX as f64).contains(value)) + { + record.priority = priority as i32; + } + continue; + } + Role::Active if flag && !previous.active() => { + target.acked_during_episode = false; + State::Active + } + Role::Active if !flag && previous.active() => { + if target.acked_during_episode { + State::ReturnedAcked + } else { + State::Returned + } + } + Role::Acked if previous.active() && flag => { + target.acked_during_episode = true; + State::ActiveAcked + } + Role::Acked if previous.active() => State::Active, + _ => continue, + }; + if record.state == previous { + continue; + } + record.at = event.source_timestamp.or(event.worker_timestamp); + if emit { + super::publish_record( + &proxy.publisher, + record, + previous, + AlarmProviderMode::Subtag, + ); + } + } + } + + pub fn records(&self) -> impl Iterator { + self.targets.values().map(|target| &target.record) + } + + pub fn ack_address_by_reference(&self, reference: &str) -> Option<&str> { + let (id, _) = self.targets.iter().find(|(_, target)| { + target + .config + .alarm_full_reference + .eq_ignore_ascii_case(reference) + })?; + self.ack_address(*id) + } + + pub fn ack_address(&self, id: Uuid) -> Option<&str> { + self.targets + .get(&id) + .map(|target| target.config.ack_comment_subtag.as_str()) + .filter(|address| !address.trim().is_empty()) + } +} + +fn numeric(value: Option<&Value>) -> Option { + match value? { + Value::BoolValue(value) => Some(if *value { 1.0 } else { 0.0 }), + Value::Int32Value(value) => Some((*value).into()), + Value::Int64Value(value) => Some(*value as f64), + Value::FloatValue(value) => Some((*value).into()), + Value::DoubleValue(value) => Some(*value), + Value::StringValue(value) if value.trim().eq_ignore_ascii_case("true") => Some(1.0), + Value::StringValue(value) if value.trim().eq_ignore_ascii_case("false") => Some(0.0), + Value::StringValue(value) => value.trim().parse().ok(), + _ => None, + } +} diff --git a/src/mxgateway-worker-rust/src/alarm/wnwrap.rs b/src/mxgateway-worker-rust/src/alarm/wnwrap.rs new file mode 100644 index 00000000..81137060 --- /dev/null +++ b/src/mxgateway-worker-rust/src/alarm/wnwrap.rs @@ -0,0 +1,203 @@ +//! x86 WnWrap interfaces from Interop.WNWRAPCONSUMERLib. The working +//! sequence uses v1 to register/subscribe and v2 to fetch the XML snapshot. + +use std::ffi::c_void; +use std::ptr::null_mut; + +use windows_sys::core::{IUnknown_Vtbl, BSTR, GUID, HRESULT, PCWSTR}; +use windows_sys::Win32::Foundation::E_FAIL; +use windows_sys::Win32::System::Com::{CoCreateInstance, CLSCTX_INPROC_SERVER}; +use windows_sys::Win32::System::Variant::{VariantClear, VARIANT, VT_BSTR}; + +use crate::automation::AutomationString; +use crate::mxevent::ComReference; + +const CLSID: GUID = GUID::from_u128(0x7ab52e5f_36b2_4a30_ae46_952a746f667c); +const IID_V1: GUID = GUID::from_u128(0x72006e35_651a_4d05_b3cb_8e4324b2e2d3); +const IID_V2: GUID = GUID::from_u128(0x9bcc2673_e5f9_4bba_b262_17c2780e276a); +const SUMMARY: i32 = 1; +const NEWEST_FIRST: i32 = 1; +const ACTIVE_NOW: i32 = 1; + +#[repr(C)] +struct Vtable { + unknown: IUnknown_Vtbl, + dispatch: [usize; 4], + register: + unsafe extern "system" fn(*mut c_void, i32, PCWSTR, PCWSTR, PCWSTR, *mut i32) -> HRESULT, + initialize: unsafe extern "system" fn(*mut c_void, PCWSTR, *mut i32) -> HRESULT, + deregister: unsafe extern "system" fn(*mut c_void, *mut i32) -> HRESULT, + uninitialize: unsafe extern "system" fn(*mut c_void, *mut i32) -> HRESULT, + select_ack_and_get_query: [usize; 5], + set_query: unsafe extern "system" fn(*mut c_void, BSTR) -> HRESULT, + get_alarms: unsafe extern "system" fn(*mut c_void, i32, *mut VARIANT) -> HRESULT, + subscribe: unsafe extern "system" fn( + *mut c_void, + PCWSTR, + i16, + i16, + i32, + i32, + i32, + i32, + *mut i32, + ) -> HRESULT, +} + +pub struct WnWrap { + v1: ComReference, + v2: ComReference, + initialized: bool, + registered: bool, +} + +impl WnWrap { + pub fn subscribe(subscription: &str) -> Result { + let mut v1 = null_mut(); + // SAFETY: the two confirmed dual interfaces stay on the calling STA. + check(unsafe { + CoCreateInstance(&CLSID, null_mut(), CLSCTX_INPROC_SERVER, &IID_V1, &mut v1) + })?; + let v1 = ComReference::new(v1)?; + let mut v2 = null_mut(); + check(unsafe { (table(&v1).unknown.QueryInterface)(v1.as_ptr(), &IID_V2, &mut v2) })?; + let mut consumer = Self { + v1, + v2: ComReference::new(v2)?, + initialized: false, + registered: false, + }; + + let application = wide("OtOpcUa.ZB.MOM.WW.MxGateway.Worker"); + let product = wide("OtOpcUa.MxGateway"); + let version = wide("1.0"); + let expression = wide(subscription); + let query = AutomationString::new(&query_xml(subscription))?; + let v1 = consumer.v1.as_ptr(); + let methods = table(&consumer.v1); + let mut result = 0; + // SAFETY: LPWSTR inputs are null-terminated for the duration of each call. + native_result( + unsafe { (methods.initialize)(v1, application.as_ptr(), &mut result) }, + result, + )?; + consumer.initialized = true; + native_result( + unsafe { + (methods.register)( + v1, + 0, + product.as_ptr(), + application.as_ptr(), + version.as_ptr(), + &mut result, + ) + }, + result, + )?; + consumer.registered = true; + native_result( + unsafe { + (methods.subscribe)( + v1, + expression.as_ptr(), + 1, + 999, + SUMMARY, + NEWEST_FIRST, + ACTIVE_NOW, + ACTIVE_NOW, + &mut result, + ) + }, + result, + )?; + check(unsafe { (table(&consumer.v2).set_query)(consumer.v2.as_ptr(), query.as_raw()) })?; + Ok(consumer) + } + + pub fn snapshot(&self, limit: i32) -> Result { + struct XmlVariant(VARIANT); + impl Drop for XmlVariant { + fn drop(&mut self) { + // SAFETY: the out parameter owns the returned Automation value. + unsafe { VariantClear(&mut self.0) }; + } + } + let mut result = XmlVariant(VARIANT::default()); + check(unsafe { (table(&self.v2).get_alarms)(self.v2.as_ptr(), limit, &mut result.0) })?; + let value = unsafe { &result.0.Anonymous.Anonymous }; + match value.vt { + VT_BSTR => Ok(unsafe { crate::automation::bstr(value.Anonymous.bstrVal) }), + 0 | 1 => Ok(String::new()), + _ => Err(E_FAIL), + } + } +} + +impl Drop for WnWrap { + fn drop(&mut self) { + let mut ignored = 0; + let v1 = self.v1.as_ptr(); + let methods = table(&self.v1); + // SAFETY: only tear down lifecycle steps that completed successfully. + unsafe { + if self.registered { + (methods.deregister)(v1, &mut ignored); + } + if self.initialized { + (methods.uninitialize)(v1, &mut ignored); + } + } + } +} + +fn table(reference: &ComReference) -> &Vtable { + // SAFETY: references in this module own IwwAlarmConsumer or IwwAlarmConsumer2. + unsafe { &**reference.as_ptr().cast::<*const Vtable>() } +} + +fn check(hr: HRESULT) -> Result<(), HRESULT> { + if hr < 0 { + Err(hr) + } else { + Ok(()) + } +} + +fn native_result(hr: HRESULT, status: i32) -> Result<(), HRESULT> { + check(hr)?; + match status { + 0 => Ok(()), + status if status < 0 => Err(status), + _ => Err(E_FAIL), + } +} + +fn wide(value: &str) -> Vec { + value.encode_utf16().chain([0]).collect() +} + +fn query_xml(subscription: &str) -> String { + use std::fmt::Write; + let default_node = std::env::var("COMPUTERNAME").unwrap_or_default(); + let expression = subscription.trim_start_matches('\\'); + let (node, remainder) = expression + .split_once('\\') + .unwrap_or((&default_node, expression)); + let (provider, group) = remainder.split_once('!').unwrap_or((remainder, "")); + let mut query = String::from( + r#""#, + ); + for (element, value) in [("NODE", node), ("PROVIDER", provider), ("GROUP", group)] { + if !value.is_empty() { + let escaped = value + .replace('&', "&") + .replace('<', "<") + .replace('>', ">"); + write!(query, "<{element}>{escaped}").unwrap(); + } + } + query.push_str(""); + query +} diff --git a/src/mxgateway-worker-rust/src/automation.rs b/src/mxgateway-worker-rust/src/automation.rs index 1872abc4..b9d8e685 100644 --- a/src/mxgateway-worker-rust/src/automation.rs +++ b/src/mxgateway-worker-rust/src/automation.rs @@ -557,7 +557,7 @@ fn unknown(variant_type: String) -> MxValue { } } -unsafe fn bstr(value: BSTR) -> String { +pub(crate) unsafe fn bstr(value: BSTR) -> String { if value.is_null() { return String::new(); } diff --git a/src/mxgateway-worker-rust/src/mxaccess.rs b/src/mxgateway-worker-rust/src/mxaccess.rs index 54ae8d88..df864192 100644 --- a/src/mxgateway-worker-rust/src/mxaccess.rs +++ b/src/mxgateway-worker-rust/src/mxaccess.rs @@ -1,7 +1,9 @@ +use crate::alarm::AlarmRuntime; use crate::automation::{AutomationString, StatusRecord, WriteValue, WriteValueError}; use crate::mxevent::{ComReference, Connection, Publisher, RecordInfoPin, WriteCompletion}; use crate::wire::mxaccess_gateway::v1::{ - BulkReadResult, BulkWriteResult, MxStatusProxy, MxValue, SubscribeResult, + BulkReadResult, BulkWriteResult, MxCommand, MxCommandReply, MxStatusProxy, MxValue, + SubscribeResult, }; use std::collections::{BTreeMap, BTreeSet}; use std::time::Duration; @@ -14,12 +16,12 @@ use std::sync::{mpsc, Arc}; use std::thread; use tokio::sync::oneshot; use windows_sys::core::{BSTR, GUID, HRESULT}; -use windows_sys::Win32::Foundation::{E_INVALIDARG, WAIT_OBJECT_0}; +use windows_sys::Win32::Foundation::{E_INVALIDARG, WAIT_OBJECT_0, WAIT_TIMEOUT}; use windows_sys::Win32::System::Com::{ CoCreateInstance, CoInitializeEx, CoUninitialize, CLSCTX_INPROC_SERVER, COINIT_APARTMENTTHREADED, }; -use windows_sys::Win32::System::Threading::{CreateEventW, SetEvent, INFINITE}; +use windows_sys::Win32::System::Threading::{CreateEventW, SetEvent}; use windows_sys::Win32::System::Variant::VARIANT; use windows_sys::Win32::UI::WindowsAndMessaging::{ DispatchMessageW, MsgWaitForMultipleObjectsEx, PeekMessageW, TranslateMessage, MSG, @@ -35,8 +37,18 @@ 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); +pub fn write_completion_wait() -> Duration { + let milliseconds = std::env::var("MXGATEWAY_WORKER_WRITE_COMPLETION_WAIT_MS") + .ok() + .and_then(|value| value.trim().parse::().ok()) + .filter(|&value| value >= 0) + .unwrap_or(1500); + Duration::from_millis(milliseconds as u64) +} + pub enum Command { Probe, + Alarm(Box), Register(String), Unregister(i32), AddItem(i32, String), @@ -106,6 +118,7 @@ impl From for CommandError { pub enum CommandResult { Done, + Alarm(Box), Handle(i32), Status(MxStatusProxy), SubscribeBulk(Vec), @@ -114,7 +127,7 @@ pub enum CommandResult { WriteBulk(Vec), } -type Outcome = Result; +pub(crate) type Outcome = Result; pub enum StartError { Io(io::Error), @@ -236,11 +249,29 @@ fn run( } fn pump(requests: &mpsc::Receiver, wake: &OwnedHandle, proxy: &mut Proxy) { + let mut alarms = AlarmRuntime::new(); + pump_loop(requests, wake, proxy, &mut alarms); + alarms.close(proxy); +} + +fn pump_loop( + requests: &mpsc::Receiver, + wake: &OwnedHandle, + proxy: &mut Proxy, + alarms: &mut AlarmRuntime, +) { let handle = wake.as_raw_handle(); loop { + alarms.poll(proxy); // SAFETY: the wait uses one valid event and the current STA's message queue. let result = unsafe { - MsgWaitForMultipleObjectsEx(1, &handle, INFINITE, QS_ALLINPUT, MWMO_INPUTAVAILABLE) + MsgWaitForMultipleObjectsEx( + 1, + &handle, + alarms.wait_millis(), + QS_ALLINPUT, + MWMO_INPUTAVAILABLE, + ) }; match result { WAIT_OBJECT_0 => loop { @@ -251,19 +282,27 @@ fn pump(requests: &mpsc::Receiver, wake: &OwnedHandle, proxy: &mut Prox if matches!(request.command, Command::Write(_)) && !pump_messages() { return; } - let _ = request.reply.send(proxy.execute(request.command)); + let result = match request.command { + Command::Alarm(command) => Ok(CommandResult::Alarm(Box::new( + alarms.execute(proxy, *command), + ))), + command => proxy.execute(command), + }; + let _ = request.reply.send(result); + alarms.poll(proxy); } Err(mpsc::TryRecvError::Empty) => break, Err(mpsc::TryRecvError::Disconnected) => return, } }, 1 if pump_messages() => {} + WAIT_TIMEOUT => {} _ => return, } } } -fn pump_messages() -> bool { +pub(crate) fn pump_messages() -> bool { let mut message = MSG::default(); // SAFETY: MSG lives across PeekMessageW and dispatch on this STA. while unsafe { PeekMessageW(&mut message, null_mut(), 0, 0, PM_REMOVE) } != 0 { @@ -346,10 +385,10 @@ struct ProxyV5Vtable { set_buffered_update_interval: unsafe extern "system" fn(*mut c_void, i32, i32) -> HRESULT, } -struct Proxy { +pub(crate) struct Proxy { interface: NonNull, registrations: BTreeSet, - publisher: Publisher, + pub(crate) publisher: Publisher, connections: Vec, items: BTreeMap<(i32, i32), String>, } @@ -383,13 +422,16 @@ impl Proxy { Ok(proxy) } - fn execute(&mut self, command: Command) -> Outcome { + pub(crate) fn execute(&mut self, command: Command) -> Outcome { let object = self.interface.as_ptr(); let table = self.vtable(); let mut handle = 0; // SAFETY: the proxy and temporary BSTRs are local to this STA. match command { Command::Probe => Ok(CommandResult::Done), + Command::Alarm(_) => { + unreachable!("alarm command must run through the STA alarm runtime") + } Command::Write(request) => self.write(*request, true).map(|completion| { CommandResult::Write(completion.expect("single write expects a completion")) }), diff --git a/src/mxgateway-worker-rust/src/mxevent.rs b/src/mxgateway-worker-rust/src/mxevent.rs index 84936971..335fdaa5 100644 --- a/src/mxgateway-worker-rust/src/mxevent.rs +++ b/src/mxgateway-worker-rust/src/mxevent.rs @@ -1,4 +1,4 @@ -use std::collections::{BTreeMap, BTreeSet}; +use std::collections::{BTreeMap, BTreeSet, VecDeque}; use std::ffi::c_void; use std::ptr::{null_mut, NonNull}; use std::sync::{ @@ -37,7 +37,7 @@ const RECORD_ID: GUID = GUID::from_u128(0xa162d9e4_9019_42f3_a087_79264007e542); #[derive(Clone, Copy)] pub enum EventFault { Overflow, - AlarmDisconnected, + AlarmPoll(HRESULT), Conversion(&'static str), } @@ -63,6 +63,7 @@ struct PublisherState { last_sequence: u64, latest_values: BTreeMap<(i32, i32), MxEvent>, pending_write: Option, + private: BTreeMap>>, } pub fn event_channel( @@ -98,8 +99,28 @@ impl Publisher { state.latest_values.remove(&(server, item)); } + pub fn private_registration(&self, server: i32, collect: bool) { + self.state + .lock() + .unwrap() + .private + .insert(server, collect.then(VecDeque::new)); + } + + pub fn private_events(&self, server: i32) -> VecDeque { + self.state + .lock() + .unwrap() + .private + .get_mut(&server) + .and_then(Option::as_mut) + .map(std::mem::take) + .unwrap_or_default() + } + pub fn unregister(&self, server: i32) { let mut state = self.state.lock().unwrap(); + state.private.remove(&server); state.advised.retain(|(handle, _)| *handle != server); state .latest_values @@ -161,6 +182,16 @@ impl Publisher { if !state.advised.contains(&key) { return; } + if let Some(queue) = state.private.get_mut(&event.server_handle) { + if let Some(queue) = queue { + if queue.len() == self.events.max_capacity() { + self.report_fault(EventFault::Overflow); + } else { + queue.push_back(event); + } + } + return; + } state.latest_values.insert(key, event.clone()); } if event.family() == MxEventFamily::OnWriteComplete @@ -173,6 +204,9 @@ impl Publisher { let _ = pending.completion.send(event.statuses.clone()); } } + if state.private.contains_key(&event.server_handle) { + return; + } match self.events.try_send(event) { Ok(()) => state.last_sequence += 1, Err(mpsc::error::TrySendError::Full(_)) => self.report_fault(EventFault::Overflow), diff --git a/src/mxgateway-worker-rust/src/session.rs b/src/mxgateway-worker-rust/src/session.rs index d52d4f2c..42805cfd 100644 --- a/src/mxgateway-worker-rust/src/session.rs +++ b/src/mxgateway-worker-rust/src/session.rs @@ -11,7 +11,7 @@ use tokio::sync::{mpsc, watch}; use tokio::time::{interval, sleep, timeout, Instant, Interval, MissedTickBehavior}; use windows_sys::Win32::Foundation::E_INVALIDARG; -use crate::alarm::{self, AlarmWorker}; +use crate::alarm; use crate::automation::int32; use crate::mxaccess::{ Command, CommandError, CommandResult, ItemOperation, Sta, StartError, WriteAccess, @@ -126,13 +126,7 @@ impl Options { heartbeat_interval: env_duration("MXGATEWAY_WORKER_HEARTBEAT_SEND_INTERVAL_MS", 5000), sta_grace: env_duration("MXGATEWAY_WORKER_HEARTBEAT_GRACE_MS", 15000), command_ceiling: env_duration("MXGATEWAY_WORKER_HEARTBEAT_STUCK_CEILING_MS", 75000), - write_completion_wait: Duration::from_millis( - std::env::var("MXGATEWAY_WORKER_WRITE_COMPLETION_WAIT_MS") - .ok() - .and_then(|value| value.parse::().ok()) - .unwrap_or(1500) - .into(), - ), + write_completion_wait: crate::mxaccess::write_completion_wait(), event_capacity: std::env::var("MXGATEWAY_EVENT_QUEUE_CAPACITY") .ok() .and_then(|value| value.parse().ok()) @@ -286,17 +280,7 @@ pub async fn run() -> Result<(), Error> { // finish a control write before reading the ack. let acknowledgement = match result { Ok(grace) => { - 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 shutdown = timeout(grace, sta.shutdown()).await; let (code, message) = match shutdown { Ok(Ok(0)) => (ProtocolStatusCode::Ok, "Graceful shutdown completed".into()), Ok(Ok(failures)) => ( @@ -322,7 +306,6 @@ pub async fn run() -> Result<(), Error> { .map_err(Error::from) } Err(error) => { - drop(events.alarm_worker.take()); let _ = timeout(Duration::from_secs(2), sta.shutdown()).await; Err(error) } @@ -518,9 +501,7 @@ async fn run_command( }); let context = ExecutorContext { options, - max, publisher: &events.publisher, - alarm_worker: &mut events.alarm_worker, }; let execution = timeout( options.command_ceiling, @@ -608,16 +589,27 @@ async fn report_event_fault( failure: EventFault, ) -> Error { let (category, message, exit_code) = match failure { + EventFault::AlarmPoll(hr) => { + let message = format!( + "Alarm polling repeatedly failed (HRESULT 0x{:08X})", + hr as u32 + ); + fault( + writer, + session, + max, + WorkerFaultCategory::MxaccessEventConversionFailed, + Some(hr), + &message, + ) + .await; + return Error(1, message); + } 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, @@ -630,9 +622,7 @@ async fn report_event_fault( struct ExecutorContext<'a> { options: &'a Options, - max: usize, publisher: &'a Publisher, - alarm_worker: &'a mut Option, } async fn execute( @@ -642,12 +632,7 @@ async fn execute( context: ExecutorContext<'_>, drain: Option, ) -> Result { - let ExecutorContext { - options, - max, - publisher, - alarm_worker, - } = context; + let ExecutorContext { options, publisher } = context; use mx_command::Payload; use mx_command_reply::Payload as Reply; use MxCommandKind as Kind; @@ -667,42 +652,16 @@ async fn execute( }; 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) + let Ok(CommandResult::Alarm(mut result)) = sta + .execute(Command::Alarm(Box::new(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) - } + .map_err(Error::sta)? + else { + unreachable!("STA alarm route returns an alarm reply"); }; + result.session_id = reply.session_id; + result.correlation_id = reply.correlation_id; + return Ok(*result); } let native = match (kind, command.payload) { (Kind::Register, Some(Payload::Register(request))) => { @@ -962,6 +921,7 @@ async fn execute( } } match sta.execute(native).await.map_err(Error::sta)? { + Ok(CommandResult::Alarm(_)) => unreachable!("data command returned an alarm reply"), Ok(CommandResult::Handle(handle)) => { if !matches!(kind, Kind::AuthenticateUser | Kind::ArchestraUserToId) { reply.return_value = Some(int32(handle)); @@ -1059,7 +1019,6 @@ struct EventStream { receiver: mpsc::Receiver, faults: watch::Receiver>, pending: Option, - alarm_worker: Option, } impl EventStream { @@ -1070,7 +1029,6 @@ impl EventStream { receiver, faults, pending: None, - alarm_worker: None, } }