Files
Marc Schier 01d7162313 Part 9 Alarms & Conditions: complete server + client implementation (#3805)
Complete implementation of **OPC UA Part 9 ΓÇö Alarms & Conditions** for
both server and client, **OPC UA Part 16 ΓÇö State Machines** (generic
extensible client + server API), and the supporting infrastructure
(source-generated event records, source-generated ObjectType proxies,
`IAsyncEnumerable` streaming subscriptions, address-space model change
tracking, per-node `INodeCache` invalidation, unified DI integration).

### Server-side (Part 9 complete)

- **`AlarmConditionState`** ΓÇö every Part 9 method wired automatically
in `OnAfterCreate`: `Silence`, `Suppress`/`Suppress2`,
`Unsuppress`/`Unsuppress2`, `RemoveFromService`/`RemoveFromService2`,
`PlaceInService`/`PlaceInService2`, `Reset`/`Reset2`,
`GetGroupMemberships`. Each method generates the spec-mandated audit
event and supports an optional veto-delegate hook.
- **Latched alarms** ΓÇö `ActiveState` reflects real process state;
`LatchedState` persists until explicit `Reset` (with full precondition
validation).
- **Re-alarming** ΓÇö
`ProcessReAlarm`/`ResetReAlarmRepeatCount`/`IsReAlarmEnabled` helpers
(opt-in, no hidden timer).
- **Audible alarms** ΓÇö `UpdateAudibleState` for
`AudibleEnabled`/`AudibleSound`/`SilenceState` lifecycle.
- **Suppression + groups** ΓÇö `AlarmGroup`, `AlarmSuppressionEngine`
(with first-in-group), `AlarmRateTracker` (for `AlarmMetricsType`).
- **Spec-compliance fixes** ΓÇö `SuppressedOrShelved` now includes
`OutOfServiceState`; `GetRetainState` includes `LatchedState`;
`EffectiveDisplayName` composition includes `OutOfServiceState` +
`LatchedState`.

### Client-side Part 9 API

- **`AlarmClient`** ΓÇö typed Part 9 operations. Each method delegates
to the matching source-generated `*TypeClient` proxy
(`ConditionTypeClient`, `AcknowledgeableConditionTypeClient`,
`AlarmConditionTypeClient`, `DialogConditionTypeClient`,
`ShelvedStateMachineTypeClient`) ΓÇö one source of truth for every
method NodeId.
- **Interface hierarchy** — `IConditionOperations` →
`IAcknowledgeableConditionOperations` → `IAlarmOperations` +
`IDialogConditionOperations`.
- **Source-generated event records** ΓÇö new `EventRecordGenerator`
(alongside `ObjectTypeProxyGenerator`) emits `{Type}TypeRecord` per OPC
UA event type: `ConditionTypeRecord` →
`AcknowledgeableConditionTypeRecord` → `AlarmConditionTypeRecord` →
`LimitAlarmTypeRecord`/`ExclusiveLimitAlarmTypeRecord`/… all the way
to vendor subtypes. **Vendor alarm types get records automatically.**
- **`AlarmEventDecoder`** ΓÇö decodes `EventNotification.Fields` into
the most-specific generated record.
- **`AlarmEventFilterBuilder`** ΓÇö fluent builder for Part 9
`EventFilter`s.
- **`ISession.GetAlarmClient(telemetry)`** convenience extension.

### Part 16 state machines (generic, extensible)

- **Client**: extension methods on the source-generated
`StateMachineTypeClient` / `FiniteStateMachineTypeClient` ΓÇö
`GetCurrentStateAsync`, `ObserveFiniteTransitionsAsync`
(`IAsyncEnumerable<FiniteStateSnapshot>`), `WaitForStateAsync`,
`GetAvailableStatesAsync` / `GetAvailableTransitionsAsync`. **Vendor
proxies inherit the API automatically** through the generated
inheritance chain.
- **Server**: `StateMachineBuilder` (fluent: `AddState` /
`AddTransition` / `OnCause` / validation) +
`FluentFiniteStateMachineState` ΓÇö declare a Part 16 state machine
without subclassing the abstract base.
- **Alarms alignment**: `AlarmClient.GetShelvingStateAsync` /
`ObserveShelvingTransitionsAsync` surface the API for every alarm's
`ShelvingState` child.

### IAsyncEnumerable streaming subscription

- **`IStreamingSubscription`** with
`SubscribeDataChangesAsync`/`SubscribeEventsAsync` returning
`IAsyncEnumerable<T>` (Channel-backed).
- **`ManagedSession.DefaultStreaming`** ΓÇö lazy shared subscription;
disposed with the session.
- **Helpers** ΓÇö `TakeUntilAsync`, `WithTimeoutAsync`, `TakeAsync`,
`BufferedAsync` for state-machine waits and bounded observation windows.
- **`AlarmStreamExtensions`** ΓÇö
`SubscribeAlarmsAsync`/`SubscribeConditionsAsync`/`SubscribeDialogsAsync`
returning the source-generated record types.

### Address-space model change tracking

- **Server**: `RaiseGeneralModelChangeEvent` on both `CustomNodeManager`
and `AsyncCustomNodeManager`; `ModelChangeAggregator` (in
`Opc.Ua.Server.NodeManager`, used by every node manager) batches changes
per service call; **auto-emit** from `CreateNode`/`DeleteNode` (opt-out
via `ModelChangeEmissionEnabled = false`).
- **Client**: `IModelChangeTracker` subscribes to
`BaseModelChangeEventType` via the streaming subscription, decodes
`ModelChangeStructureDataType` payloads, invalidates the `INodeCache`
per-node.
- **`INodeCache.InvalidateNode(NodeId)`** ΓÇö new interface member (true
per-node eviction in `NodeCache`).
- **`ManagedSession.EnableModelChangeTrackingAsync()`** +
`ManagedSessionOptions.ModelChangeTracking` +
`ManagedSessionBuilder.WithModelChangeTracking()` fluent method.

### Dependency Injection integration

- **`services.AddOpcUa().AddClient(...).AddAlarms()`** ΓÇö registers
`AlarmClientFactory` so DI-hosted apps can resolve a Part 9 client per
session without `new`-ing one manually.
- Cross-link added to the unified DI surface (`AddServer` / `AddClient`
/ `AddComplexTypes` / `AddGdsServer` / `AddLdsServer` /
`AddWotConServer`).

### Quickstart server modernization

- `Quickstarts.Servers/Alarms/AlarmNodeManager.cs` ported to
`AsyncCustomNodeManager` and demonstrates the new `AlarmGroup` +
`AlarmSuppressionEngine` end-to-end via a writable `MaintenanceMode`
boolean that suppresses every member alarm.

### Documentation

- New: `Docs/AlarmsAndConditions.md`, `Docs/StreamingSubscription.md`,
`Docs/ModelChangeTracking.md`, `Docs/StateMachines.md` ΓÇö full
developer guides.
- Updated: `Docs/DependencyInjection.md` (`AddAlarms()` row + section),
`Docs/README.md` index, `Docs/MigrationGuide.md` (Part 9 / Part 16 /
model change tracking sections covering behavior changes + breaking API
surface).
- Sample: `Applications/ConsoleReferenceClient/AlarmClientSample.cs`.
2026-05-29 23:24:53 +02:00

123 lines
5.6 KiB
C#

/* ========================================================================
* Copyright (c) 2005-2025 The OPC Foundation, Inc. All rights reserved.
*
* OPC Foundation MIT License 1.00
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use,
* copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following
* conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* The complete license agreement can be found here:
* http://opcfoundation.org/License/MIT/1.00/
* ======================================================================*/
using System;
namespace Opc.Ua.Client.StateMachines
{
/// <summary>
/// A point-in-time snapshot of an OPC UA Part 16 state machine.
/// Returned by <c>StateMachineTypeClient.GetCurrentStateAsync</c>
/// and yielded by <c>StateMachineTypeClient.ObserveStateChangesAsync</c>.
/// </summary>
/// <remarks>
/// The non-finite variant only carries the
/// <c>StateVariableType</c> value
/// (<see cref="CurrentState"/> as <see cref="LocalizedText"/>).
/// Finite state machines yield the richer
/// <see cref="FiniteStateSnapshot"/> with the typed state and
/// transition NodeIds.
/// </remarks>
/// <param name="StateMachineId">The NodeId of the state machine instance.</param>
/// <param name="CurrentState">The current state's localized name.</param>
/// <param name="Timestamp">The source timestamp of the observation.</param>
/// <param name="Status">The status code reported with the observation.</param>
public sealed record StateMachineSnapshot(
NodeId StateMachineId,
LocalizedText CurrentState,
DateTime Timestamp,
StatusCode Status);
/// <summary>
/// A point-in-time snapshot of an OPC UA Part 16
/// <c>FiniteStateMachineType</c> instance. Adds the typed state
/// and transition NodeIds on top of <see cref="StateMachineSnapshot"/>.
/// </summary>
/// <param name="StateMachineId">The NodeId of the state machine instance.</param>
/// <param name="CurrentState">The current state's localized name.</param>
/// <param name="CurrentStateId">The current state's NodeId (the
/// <c>StateType</c> instance the machine is currently in).</param>
/// <param name="LastTransition">The last transition's localized
/// name. May be <c>LocalizedText.Null</c> if no transition has
/// occurred since the state machine was created.</param>
/// <param name="LastTransitionId">The last transition's NodeId.
/// May be <c>NodeId.Null</c> if no transition has occurred.</param>
/// <param name="Timestamp">The source timestamp of the observation.</param>
/// <param name="Status">The status code reported with the observation.</param>
public sealed record FiniteStateSnapshot(
NodeId StateMachineId,
LocalizedText CurrentState,
NodeId CurrentStateId,
LocalizedText LastTransition,
NodeId LastTransitionId,
DateTime Timestamp,
StatusCode Status)
{
/// <summary>
/// When the FSM has a sub-state-machine attached to its
/// current state via <c>HasSubStateMachine</c>, this holds
/// the sub-SM's snapshot. <c>null</c> for state machines
/// without sub-SMs or when the current state has no
/// attached sub-SM.
/// </summary>
public FiniteStateSnapshot? SubMachine { get; init; }
}
/// <summary>
/// Describes a state node defined on a finite state machine type.
/// Returned by
/// <c>FiniteStateMachineTypeClient.GetAvailableStatesAsync</c>.
/// </summary>
/// <param name="NodeId">The NodeId of the <c>StateType</c> instance.</param>
/// <param name="BrowseName">The browse name (e.g. <c>Unshelved</c>).</param>
/// <param name="StateNumber">The state number declared by the
/// type (Part 16 §B.4.3). Zero when the server does not expose
/// the <c>StateNumber</c> property.</param>
public sealed record FiniteStateInfo(
NodeId NodeId,
QualifiedName BrowseName,
uint StateNumber);
/// <summary>
/// Describes a transition node defined on a finite state machine
/// type. Returned by
/// <c>FiniteStateMachineTypeClient.GetAvailableTransitionsAsync</c>.
/// </summary>
/// <param name="NodeId">The NodeId of the <c>TransitionType</c> instance.</param>
/// <param name="BrowseName">The browse name (e.g.
/// <c>UnshelvedToTimedShelved</c>).</param>
/// <param name="TransitionNumber">The transition number declared
/// by the type. Zero when the server does not expose the
/// <c>TransitionNumber</c> property.</param>
public sealed record FiniteTransitionInfo(
NodeId NodeId,
QualifiedName BrowseName,
uint TransitionNumber);
}