Joseph Doherty
0d30b7dec0
Adds IAlarmSubscribableConnection to OpcUaDataConnection, IOpcUaClient alarm subscription methods, and RealOpcUaClient A&C event monitored-item + EventFilter + ConditionRefresh snapshot, mapping fields via OpcUaAlarmMapper. Behavior verified against a live A&C server in Task 28; mapper unit-tested.
630 lines
28 KiB
C#
630 lines
28 KiB
C#
using System.Collections.Concurrent;
|
|
using System.Security.Cryptography.X509Certificates;
|
|
using Microsoft.Extensions.Logging;
|
|
using Microsoft.Extensions.Logging.Abstractions;
|
|
using Opc.Ua;
|
|
using Opc.Ua.Client;
|
|
using Opc.Ua.Configuration;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Types.Alarms;
|
|
using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
|
|
|
|
namespace ZB.MOM.WW.ScadaBridge.DataConnectionLayer.Adapters;
|
|
|
|
/// <summary>
|
|
/// Real OPC UA client implementation using the OPC Foundation .NET Standard Library.
|
|
/// Wraps Session, Subscription, and MonitoredItem for tag subscriptions.
|
|
/// </summary>
|
|
public class RealOpcUaClient : IOpcUaClient
|
|
{
|
|
private ISession? _session;
|
|
private Subscription? _subscription;
|
|
|
|
// DataConnectionLayer-003: these maps are read from the OPC Foundation SDK's
|
|
// internal publish threads (the MonitoredItem.Notification handler reads
|
|
// _callbacks) concurrently with subscribe/disconnect mutations that run on
|
|
// thread-pool threads. Plain Dictionary access during a concurrent resize or
|
|
// Clear() is undefined behaviour, so they must be ConcurrentDictionary.
|
|
private readonly ConcurrentDictionary<string, MonitoredItem> _monitoredItems = new();
|
|
private readonly ConcurrentDictionary<string, Action<string, object?, DateTime, uint>> _callbacks = new();
|
|
|
|
// Task-11: native alarm (A&C) event subscriptions, keyed by handle.
|
|
private readonly ConcurrentDictionary<string, MonitoredItem> _alarmItems = new();
|
|
// Per-handle "currently inside a ConditionRefresh replay" flag → Snapshot kind.
|
|
private readonly ConcurrentDictionary<string, bool> _alarmInRefresh = new();
|
|
// Per-handle last (active, acked) by source reference, to derive transition kind.
|
|
private readonly ConcurrentDictionary<string, Dictionary<string, (bool Active, bool Acked)>> _alarmLastState = new();
|
|
// DataConnectionLayer-013: int flag toggled with Interlocked.Exchange so the
|
|
// once-only ConnectionLost guard in OnSessionKeepAlive is atomic, not just visible.
|
|
// 0 = not fired, 1 = fired.
|
|
private int _connectionLostFired;
|
|
private OpcUaConnectionOptions _options = new();
|
|
private readonly OpcUaGlobalOptions _globalOptions;
|
|
private readonly ILogger<RealOpcUaClient> _logger;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the RealOpcUaClient class.
|
|
/// </summary>
|
|
/// <param name="globalOptions">Global OPC UA options, or null to use defaults.</param>
|
|
/// <param name="logger">Logger instance, or null to use a null logger.</param>
|
|
public RealOpcUaClient(OpcUaGlobalOptions? globalOptions = null, ILogger<RealOpcUaClient>? logger = null)
|
|
{
|
|
_globalOptions = globalOptions ?? new OpcUaGlobalOptions();
|
|
_logger = logger ?? NullLogger<RealOpcUaClient>.Instance;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public bool IsConnected => _session?.Connected ?? false;
|
|
|
|
/// <summary>Raised when the OPC UA connection is lost.</summary>
|
|
public event Action? ConnectionLost;
|
|
|
|
/// <inheritdoc />
|
|
public async Task ConnectAsync(string endpointUrl, OpcUaConnectionOptions? options = null, CancellationToken cancellationToken = default)
|
|
{
|
|
var opts = options ?? new OpcUaConnectionOptions();
|
|
|
|
var preferredSecurityMode = opts.SecurityMode?.ToUpperInvariant() switch
|
|
{
|
|
"SIGN" => MessageSecurityMode.Sign,
|
|
"SIGNANDENCRYPT" => MessageSecurityMode.SignAndEncrypt,
|
|
_ => MessageSecurityMode.None
|
|
};
|
|
|
|
var appConfig = new ApplicationConfiguration
|
|
{
|
|
ApplicationName = string.IsNullOrWhiteSpace(_globalOptions.ApplicationName)
|
|
? "ScadaBridge-DCL"
|
|
: _globalOptions.ApplicationName,
|
|
ApplicationType = ApplicationType.Client,
|
|
SecurityConfiguration = new SecurityConfiguration
|
|
{
|
|
AutoAcceptUntrustedCertificates = opts.AutoAcceptUntrustedCerts,
|
|
ApplicationCertificate = new CertificateIdentifier(),
|
|
TrustedIssuerCertificates = new CertificateTrustList { StorePath = ResolveStorePath(_globalOptions.TrustedIssuerStorePath, "issuers") },
|
|
TrustedPeerCertificates = new CertificateTrustList { StorePath = ResolveStorePath(_globalOptions.TrustedPeerStorePath, "trusted") },
|
|
RejectedCertificateStore = new CertificateTrustList { StorePath = ResolveStorePath(_globalOptions.RejectedCertificateStorePath, "rejected") }
|
|
},
|
|
ClientConfiguration = new ClientConfiguration { DefaultSessionTimeout = opts.SessionTimeoutMs },
|
|
TransportQuotas = new TransportQuotas { OperationTimeout = opts.OperationTimeoutMs }
|
|
};
|
|
|
|
await appConfig.ValidateAsync(ApplicationType.Client);
|
|
if (opts.AutoAcceptUntrustedCerts)
|
|
{
|
|
// DataConnectionLayer-012: this accepts ANY server certificate, defeating
|
|
// certificate trust enforcement. Surface a prominent warning so an operator
|
|
// who has opted in is aware of the man-in-the-middle exposure on the link.
|
|
_logger.LogWarning(
|
|
"OPC UA connection to {Endpoint} has AutoAcceptUntrustedCerts enabled — every " +
|
|
"server certificate is accepted unconditionally. This defeats Sign / " +
|
|
"SignAndEncrypt protection against a man-in-the-middle.", endpointUrl);
|
|
appConfig.CertificateValidator.CertificateValidation += (_, e) => e.Accept = true;
|
|
}
|
|
|
|
// Discover endpoints from the server, pick the preferred security mode
|
|
EndpointDescription? endpoint;
|
|
try
|
|
{
|
|
#pragma warning disable CS0618
|
|
using var discoveryClient = DiscoveryClient.Create(new Uri(endpointUrl));
|
|
#pragma warning restore CS0618
|
|
#pragma warning disable CS0618
|
|
var endpoints = discoveryClient.GetEndpoints(null);
|
|
#pragma warning restore CS0618
|
|
endpoint = endpoints
|
|
.Where(e => e.SecurityMode == preferredSecurityMode)
|
|
.FirstOrDefault() ?? endpoints.FirstOrDefault();
|
|
}
|
|
catch
|
|
{
|
|
// Fallback: construct endpoint description manually
|
|
endpoint = new EndpointDescription(endpointUrl);
|
|
}
|
|
|
|
var endpointConfig = EndpointConfiguration.Create(appConfig);
|
|
var configuredEndpoint = new ConfiguredEndpoint(null, endpoint, endpointConfig);
|
|
|
|
#pragma warning disable CS0618 // Allow obsolete DefaultSessionFactory constructor for compatibility
|
|
var sessionFactory = new DefaultSessionFactory();
|
|
#pragma warning restore CS0618
|
|
var userIdentity = BuildUserIdentity(opts.UserIdentity);
|
|
_session = await sessionFactory.CreateAsync(
|
|
appConfig, configuredEndpoint, false,
|
|
"ScadaBridge-DCL-Session", (uint)opts.SessionTimeoutMs, userIdentity, null, cancellationToken);
|
|
|
|
// Detect server going offline via keep-alive failures
|
|
Interlocked.Exchange(ref _connectionLostFired, 0);
|
|
_session.KeepAlive += OnSessionKeepAlive;
|
|
|
|
// Store options for monitored item creation
|
|
_options = opts;
|
|
|
|
// Create a default subscription for all monitored items
|
|
_subscription = new Subscription(_session.DefaultSubscription)
|
|
{
|
|
DisplayName = opts.SubscriptionDisplayName,
|
|
Priority = opts.SubscriptionPriority,
|
|
PublishingEnabled = true,
|
|
PublishingInterval = opts.PublishingIntervalMs,
|
|
KeepAliveCount = (uint)opts.KeepAliveCount,
|
|
LifetimeCount = (uint)opts.LifetimeCount,
|
|
MaxNotificationsPerPublish = (uint)opts.MaxNotificationsPerPublish
|
|
};
|
|
|
|
_session.AddSubscription(_subscription);
|
|
await _subscription.CreateAsync(cancellationToken);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async Task DisconnectAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
if (_subscription != null)
|
|
{
|
|
await _subscription.DeleteAsync(true);
|
|
_subscription = null;
|
|
}
|
|
if (_session != null)
|
|
{
|
|
_session.KeepAlive -= OnSessionKeepAlive;
|
|
await _session.CloseAsync(cancellationToken);
|
|
_session = null;
|
|
}
|
|
_monitoredItems.Clear();
|
|
_callbacks.Clear();
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async Task<string> CreateSubscriptionAsync(
|
|
string nodeId, Action<string, object?, DateTime, uint> onValueChanged,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
if (_subscription == null || _session == null)
|
|
throw new InvalidOperationException("Not connected.");
|
|
|
|
var handle = Guid.NewGuid().ToString();
|
|
var monitoredItem = new MonitoredItem(_subscription.DefaultItem)
|
|
{
|
|
DisplayName = nodeId,
|
|
StartNodeId = nodeId,
|
|
AttributeId = Attributes.Value,
|
|
SamplingInterval = _options.SamplingIntervalMs,
|
|
QueueSize = (uint)_options.QueueSize,
|
|
DiscardOldest = _options.DiscardOldest,
|
|
Filter = BuildDataChangeFilter(_options.Deadband)
|
|
};
|
|
|
|
_callbacks[handle] = onValueChanged;
|
|
|
|
monitoredItem.Notification += (item, e) =>
|
|
{
|
|
if (e.NotificationValue is MonitoredItemNotification notification)
|
|
{
|
|
var value = notification.Value?.Value;
|
|
var timestamp = notification.Value?.SourceTimestamp ?? DateTime.UtcNow;
|
|
var statusCode = notification.Value?.StatusCode.Code ?? 0;
|
|
|
|
if (_callbacks.TryGetValue(handle, out var cb))
|
|
{
|
|
cb(nodeId, value, timestamp, statusCode);
|
|
}
|
|
}
|
|
};
|
|
|
|
_subscription.AddItem(monitoredItem);
|
|
await _subscription.ApplyChangesAsync(cancellationToken);
|
|
|
|
_monitoredItems[handle] = monitoredItem;
|
|
return handle;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async Task RemoveSubscriptionAsync(string subscriptionHandle, CancellationToken cancellationToken = default)
|
|
{
|
|
if (_subscription != null && _monitoredItems.TryGetValue(subscriptionHandle, out var item))
|
|
{
|
|
_subscription.RemoveItem(item);
|
|
await _subscription.ApplyChangesAsync(cancellationToken);
|
|
_monitoredItems.TryRemove(subscriptionHandle, out _);
|
|
_callbacks.TryRemove(subscriptionHandle, out _);
|
|
}
|
|
}
|
|
|
|
// ── Native alarm (Alarms & Conditions) subscription (Task-11) ──
|
|
// Behavioral correctness verified against a live A&C server in Task 28; only
|
|
// the OpcUaAlarmMapper value→state logic is unit-tested.
|
|
|
|
// Fixed select-clause order; parsed by index in HandleAlarmEvent.
|
|
private static readonly string[] AlarmStateFields =
|
|
["EventType", "SourceNode", "SourceName", "Time", "Message", "Severity"];
|
|
|
|
/// <inheritdoc />
|
|
public async Task<string> CreateAlarmSubscriptionAsync(
|
|
string? sourceNodeId, string? conditionFilter,
|
|
Action<NativeAlarmTransition> onTransition, CancellationToken cancellationToken = default)
|
|
{
|
|
if (_subscription == null || _session == null)
|
|
throw new InvalidOperationException("Not connected.");
|
|
|
|
var handle = Guid.NewGuid().ToString();
|
|
_alarmInRefresh[handle] = false;
|
|
_alarmLastState[handle] = new Dictionary<string, (bool, bool)>(StringComparer.Ordinal);
|
|
|
|
var startNode = string.IsNullOrEmpty(sourceNodeId) ? ObjectIds.Server : NodeId.Parse(sourceNodeId);
|
|
var item = new MonitoredItem(_subscription.DefaultItem)
|
|
{
|
|
DisplayName = $"alarm:{sourceNodeId ?? "Server"}",
|
|
StartNodeId = startNode,
|
|
AttributeId = Attributes.EventNotifier,
|
|
MonitoringMode = MonitoringMode.Reporting,
|
|
SamplingInterval = 0,
|
|
QueueSize = 1000,
|
|
Filter = BuildAlarmEventFilter()
|
|
};
|
|
|
|
item.Notification += (_, e) =>
|
|
{
|
|
if (e.NotificationValue is EventFieldList efl)
|
|
HandleAlarmEvent(handle, efl, onTransition);
|
|
};
|
|
|
|
_subscription.AddItem(item);
|
|
await _subscription.ApplyChangesAsync(cancellationToken);
|
|
_alarmItems[handle] = item;
|
|
|
|
// Replay currently-active conditions as a Snapshot…SnapshotComplete sequence.
|
|
await TriggerConditionRefreshAsync(handle, cancellationToken);
|
|
return handle;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async Task RemoveAlarmSubscriptionAsync(string subscriptionHandle, CancellationToken cancellationToken = default)
|
|
{
|
|
if (_subscription != null && _alarmItems.TryRemove(subscriptionHandle, out var item))
|
|
{
|
|
_subscription.RemoveItem(item);
|
|
await _subscription.ApplyChangesAsync(cancellationToken);
|
|
}
|
|
_alarmInRefresh.TryRemove(subscriptionHandle, out _);
|
|
_alarmLastState.TryRemove(subscriptionHandle, out _);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Builds the event filter selecting the base event fields plus the
|
|
/// AlarmConditionType / AcknowledgeableConditionType state sub-variables we mirror.
|
|
/// </summary>
|
|
private static EventFilter BuildAlarmEventFilter()
|
|
{
|
|
var filter = new EventFilter();
|
|
foreach (var name in AlarmStateFields)
|
|
filter.SelectClauses.Add(SelectField(ObjectTypeIds.BaseEventType, name));
|
|
|
|
// Two-state sub-condition /Id booleans + shelving current-state + identity.
|
|
filter.SelectClauses.Add(SelectField(ObjectTypeIds.AlarmConditionType, "ActiveState", "Id")); // 6
|
|
filter.SelectClauses.Add(SelectField(ObjectTypeIds.AcknowledgeableConditionType, "AckedState", "Id")); // 7
|
|
filter.SelectClauses.Add(SelectField(ObjectTypeIds.AcknowledgeableConditionType, "ConfirmedState", "Id"));// 8
|
|
filter.SelectClauses.Add(SelectField(ObjectTypeIds.AlarmConditionType, "SuppressedState", "Id")); // 9
|
|
filter.SelectClauses.Add(SelectField(ObjectTypeIds.AlarmConditionType, "ShelvingState", "CurrentState"));// 10
|
|
filter.SelectClauses.Add(SelectField(ObjectTypeIds.ConditionType, "ConditionName")); // 11
|
|
filter.SelectClauses.Add(SelectField(ObjectTypeIds.ConditionType, "Comment")); // 12
|
|
return filter;
|
|
}
|
|
|
|
private static SimpleAttributeOperand SelectField(NodeId typeDefinitionId, params string[] browse)
|
|
{
|
|
var path = new QualifiedNameCollection();
|
|
foreach (var b in browse)
|
|
path.Add(new QualifiedName(b));
|
|
return new SimpleAttributeOperand
|
|
{
|
|
TypeDefinitionId = typeDefinitionId,
|
|
BrowsePath = path,
|
|
AttributeId = Attributes.Value
|
|
};
|
|
}
|
|
|
|
private async Task TriggerConditionRefreshAsync(string handle, CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
// ConditionRefresh replays active conditions; RefreshStart/End events
|
|
// bracket the replay so HandleAlarmEvent can mark them Snapshot.
|
|
await _session!.CallAsync(
|
|
ObjectTypeIds.ConditionType, MethodIds.ConditionType_ConditionRefresh,
|
|
cancellationToken, _subscription!.Id);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogWarning(ex, "ConditionRefresh failed for alarm subscription {Handle}", handle);
|
|
}
|
|
}
|
|
|
|
private void HandleAlarmEvent(string handle, EventFieldList efl, Action<NativeAlarmTransition> onTransition)
|
|
{
|
|
var fields = efl.EventFields;
|
|
if (fields == null || fields.Count < AlarmStateFields.Length)
|
|
return;
|
|
|
|
var eventType = fields[0].Value as NodeId;
|
|
|
|
// RefreshStart/End bracket the snapshot replay.
|
|
if (eventType == ObjectTypeIds.RefreshStartEventType)
|
|
{
|
|
_alarmInRefresh[handle] = true;
|
|
return;
|
|
}
|
|
if (eventType == ObjectTypeIds.RefreshEndEventType)
|
|
{
|
|
_alarmInRefresh[handle] = false;
|
|
onTransition(SnapshotComplete());
|
|
return;
|
|
}
|
|
|
|
var sourceName = fields[1].Value is NodeId ? (fields[2].Value as string ?? "") : (fields[2].Value as string ?? "");
|
|
var conditionName = fields.Count > 11 ? fields[11].Value as string : null;
|
|
var sourceObjectRef = sourceName;
|
|
var sourceRef = string.IsNullOrEmpty(conditionName) ? sourceName : $"{sourceName}.{conditionName}";
|
|
if (string.IsNullOrEmpty(sourceRef))
|
|
return; // not a condition event we can key
|
|
|
|
var time = fields[3].Value is DateTime dt ? new DateTimeOffset(dt, TimeSpan.Zero) : DateTimeOffset.UtcNow;
|
|
var message = (fields[4].Value as LocalizedText)?.Text ?? "";
|
|
var severity = fields[5].Value is null ? 0 : Convert.ToInt32(fields[5].Value);
|
|
|
|
var active = fields.Count > 6 && fields[6].Value is bool a && a;
|
|
var acked = fields.Count <= 7 || fields[7].Value is not bool ak || ak; // default acked when absent
|
|
bool? confirmed = fields.Count > 8 && fields[8].Value is bool cf ? cf : null;
|
|
var suppressed = fields.Count > 9 && fields[9].Value is bool sp && sp;
|
|
var shelve = OpcUaAlarmMapper.MapShelve(fields.Count > 10 ? (fields[10].Value as LocalizedText)?.Text : null);
|
|
var comment = fields.Count > 12 ? (fields[12].Value as LocalizedText)?.Text ?? "" : "";
|
|
|
|
var inRefresh = _alarmInRefresh.GetValueOrDefault(handle);
|
|
var lastState = _alarmLastState.GetValueOrDefault(handle);
|
|
var (prevActive, prevAcked) = lastState != null && lastState.TryGetValue(sourceRef, out var prev) ? prev : (false, true);
|
|
var kind = inRefresh
|
|
? AlarmTransitionKind.Snapshot
|
|
: OpcUaAlarmMapper.DeriveKind(prevAcked, acked, prevActive, active);
|
|
lastState?.TryAdd(sourceRef, (active, acked));
|
|
if (lastState != null) lastState[sourceRef] = (active, acked);
|
|
|
|
onTransition(new NativeAlarmTransition(
|
|
SourceReference: sourceRef,
|
|
SourceObjectReference: sourceObjectRef,
|
|
AlarmTypeName: eventType?.ToString() ?? "",
|
|
Kind: kind,
|
|
Condition: OpcUaAlarmMapper.BuildCondition(active, acked, confirmed, shelve, suppressed, severity),
|
|
Category: "",
|
|
Description: "",
|
|
Message: message,
|
|
OperatorUser: "",
|
|
OperatorComment: comment,
|
|
OriginalRaiseTime: null,
|
|
TransitionTime: time,
|
|
CurrentValue: "",
|
|
LimitValue: ""));
|
|
}
|
|
|
|
private static NativeAlarmTransition SnapshotComplete() => new(
|
|
"", "", "", AlarmTransitionKind.SnapshotComplete,
|
|
new Commons.Types.Alarms.AlarmConditionState(false, true, null, AlarmShelveState.Unshelved, false, 0),
|
|
"", "", "", "", "", null, DateTimeOffset.UtcNow, "", "");
|
|
|
|
/// <inheritdoc />
|
|
public async Task<(object? Value, DateTime SourceTimestamp, uint StatusCode)> ReadValueAsync(
|
|
string nodeId, CancellationToken cancellationToken = default)
|
|
{
|
|
if (_session == null) throw new InvalidOperationException("Not connected.");
|
|
|
|
var readValue = new ReadValueId
|
|
{
|
|
NodeId = nodeId,
|
|
AttributeId = Attributes.Value
|
|
};
|
|
|
|
var response = await _session.ReadAsync(
|
|
null, 0, MapTimestampsToReturn(_options.TimestampsToReturn),
|
|
new ReadValueIdCollection { readValue }, cancellationToken);
|
|
|
|
var result = response.Results[0];
|
|
return (result.Value, result.SourceTimestamp, result.StatusCode.Code);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async Task<uint> WriteValueAsync(string nodeId, object? value, CancellationToken cancellationToken = default)
|
|
{
|
|
if (_session == null) throw new InvalidOperationException("Not connected.");
|
|
|
|
var writeValue = new WriteValue
|
|
{
|
|
NodeId = nodeId,
|
|
AttributeId = Attributes.Value,
|
|
Value = new DataValue(new Variant(value))
|
|
};
|
|
|
|
var response = await _session.WriteAsync(
|
|
null, new WriteValueCollection { writeValue }, cancellationToken);
|
|
|
|
return response.Results[0].Code;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called by the OPC UA SDK when a keep-alive response arrives (or fails).
|
|
/// When CurrentState is bad, the server is unreachable. The once-only guard is an
|
|
/// atomic compare-and-set, so a burst of failed keep-alives raises
|
|
/// <see cref="ConnectionLost"/> exactly once.
|
|
/// </summary>
|
|
private void OnSessionKeepAlive(ISession session, KeepAliveEventArgs e)
|
|
{
|
|
if (ServiceResult.IsBad(e.Status))
|
|
{
|
|
if (Interlocked.Exchange(ref _connectionLostFired, 1) != 0) return;
|
|
ConnectionLost?.Invoke();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Asynchronously disposes the OPC UA client, disconnecting from the server.
|
|
/// </summary>
|
|
/// <returns>A task representing the asynchronous disposal.</returns>
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
await DisconnectAsync();
|
|
}
|
|
|
|
private static UserIdentity? BuildUserIdentity(OpcUaUserIdentityOptions? options)
|
|
{
|
|
if (options is null) return null;
|
|
return options.TokenType.ToUpperInvariant() switch
|
|
{
|
|
"USERNAMEPASSWORD" => new UserIdentity(
|
|
options.Username,
|
|
System.Text.Encoding.UTF8.GetBytes(options.Password ?? "")),
|
|
"X509CERTIFICATE" => new UserIdentity(
|
|
X509CertificateLoader.LoadPkcs12FromFile(
|
|
options.CertificatePath, options.CertificatePassword)),
|
|
_ => null
|
|
};
|
|
}
|
|
|
|
private static MonitoringFilter? BuildDataChangeFilter(OpcUaDeadbandOptions? deadband)
|
|
{
|
|
if (deadband is null) return null;
|
|
var deadbandType = deadband.Type.ToUpperInvariant() switch
|
|
{
|
|
"PERCENT" => DeadbandType.Percent,
|
|
_ => DeadbandType.Absolute
|
|
};
|
|
return new DataChangeFilter
|
|
{
|
|
Trigger = DataChangeTrigger.StatusValue,
|
|
DeadbandType = (uint)deadbandType,
|
|
DeadbandValue = deadband.Value
|
|
};
|
|
}
|
|
|
|
private static TimestampsToReturn MapTimestampsToReturn(string mode) =>
|
|
mode.ToUpperInvariant() switch
|
|
{
|
|
"SERVER" => TimestampsToReturn.Server,
|
|
"BOTH" => TimestampsToReturn.Both,
|
|
_ => TimestampsToReturn.Source
|
|
};
|
|
|
|
private static string ResolveStorePath(string configured, string fallbackLeaf) =>
|
|
string.IsNullOrWhiteSpace(configured)
|
|
? Path.Combine(Path.GetTempPath(), "ScadaBridge", "pki", fallbackLeaf)
|
|
: configured;
|
|
|
|
/// <inheritdoc />
|
|
public async Task<Commons.Interfaces.Protocol.BrowseChildrenResult> BrowseChildrenAsync(
|
|
string? parentNodeId, CancellationToken cancellationToken = default)
|
|
{
|
|
// Mirror the SubscribeAsync/ReadAsync wrap idiom: snapshot the session
|
|
// reference once, fail fast with a typed exception if the link is
|
|
// down, then call the SDK's async API directly (no Task.Run wrap —
|
|
// the OPC Foundation SDK already provides true async I/O).
|
|
var session = _session;
|
|
if (session is null || !session.Connected)
|
|
{
|
|
throw new Commons.Interfaces.Protocol.ConnectionNotConnectedException(
|
|
"OPC UA session is not connected.");
|
|
}
|
|
|
|
// ObjectsFolder = ns=0;i=85 — the OPC UA standard server root. Empty
|
|
// / null input means "browse the root"; anything else is parsed as
|
|
// an absolute NodeId expression.
|
|
var nodeToBrowse = string.IsNullOrEmpty(parentNodeId)
|
|
? ObjectIds.ObjectsFolder
|
|
: NodeId.Parse(parentNodeId);
|
|
|
|
// NodeClassMask intentionally excludes ReferenceType, View, Variable-
|
|
// Type, ObjectType, DataType. UI only needs Objects (navigable),
|
|
// Variables (selectable), Methods (display-only).
|
|
var nodeClassMask = (uint)(NodeClass.Object | NodeClass.Variable | NodeClass.Method);
|
|
|
|
// requestedMaxReferencesPerNode: cap the server's per-call references so a
|
|
// huge flat folder cannot return an unbounded set. 500 leaves headroom for
|
|
// the downstream frame-size budget (DataConnectionActor.CapBrowseChildren)
|
|
// even with long string NodeIds; a non-empty continuation point surfaces as
|
|
// Truncated, prompting manual entry rather than auto-paging.
|
|
var (_, continuationPoint, references) = await session.BrowseAsync(
|
|
null,
|
|
null,
|
|
nodeToBrowse,
|
|
500u,
|
|
BrowseDirection.Forward,
|
|
ReferenceTypeIds.HierarchicalReferences,
|
|
true,
|
|
nodeClassMask,
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
var refs = references ?? new ReferenceDescriptionCollection();
|
|
var children = new List<Commons.Interfaces.Protocol.BrowseNode>(refs.Count);
|
|
foreach (var r in refs)
|
|
{
|
|
children.Add(new Commons.Interfaces.Protocol.BrowseNode(
|
|
NodeId: r.NodeId.ToString(),
|
|
DisplayName: r.DisplayName?.Text ?? r.BrowseName?.Name ?? "(unnamed)",
|
|
NodeClass: MapNodeClass(r.NodeClass),
|
|
HasChildren: r.NodeClass == NodeClass.Object));
|
|
}
|
|
|
|
// A non-empty continuation point means the server had more refs than
|
|
// our requestedMaxReferencesPerNode cap. The UI surfaces a "more
|
|
// children, type the node id manually" hint rather than auto-paging;
|
|
// BrowseNext is not invoked here. Discarding the continuation point
|
|
// is acceptable because the server expires it on session close.
|
|
var truncated = continuationPoint != null && continuationPoint.Length > 0;
|
|
return new Commons.Interfaces.Protocol.BrowseChildrenResult(children, truncated);
|
|
}
|
|
|
|
private static Commons.Interfaces.Protocol.BrowseNodeClass MapNodeClass(NodeClass nc) => nc switch
|
|
{
|
|
NodeClass.Object => Commons.Interfaces.Protocol.BrowseNodeClass.Object,
|
|
NodeClass.Variable => Commons.Interfaces.Protocol.BrowseNodeClass.Variable,
|
|
NodeClass.Method => Commons.Interfaces.Protocol.BrowseNodeClass.Method,
|
|
_ => Commons.Interfaces.Protocol.BrowseNodeClass.Other
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Factory that creates real OPC UA client instances using the OPC Foundation SDK.
|
|
/// </summary>
|
|
public class RealOpcUaClientFactory : IOpcUaClientFactory
|
|
{
|
|
private readonly OpcUaGlobalOptions _globalOptions;
|
|
|
|
// DataConnectionLayer-014: a real logger must be threaded through to every
|
|
// RealOpcUaClient this factory builds, otherwise the DCL-012 auto-accept-certificate
|
|
// warning emitted in RealOpcUaClient.ConnectAsync sinks into NullLogger and is never
|
|
// seen in production. The factory is constructed by DataConnectionFactory, which has
|
|
// an ILoggerFactory available.
|
|
private readonly ILoggerFactory _loggerFactory;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the RealOpcUaClientFactory class with default options.
|
|
/// </summary>
|
|
public RealOpcUaClientFactory() : this(new OpcUaGlobalOptions()) { }
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the RealOpcUaClientFactory class with global options.
|
|
/// </summary>
|
|
/// <param name="globalOptions">Global OPC UA options.</param>
|
|
public RealOpcUaClientFactory(OpcUaGlobalOptions globalOptions)
|
|
: this(globalOptions, NullLoggerFactory.Instance) { }
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the RealOpcUaClientFactory class with options and logger factory.
|
|
/// </summary>
|
|
/// <param name="globalOptions">Global OPC UA options.</param>
|
|
/// <param name="loggerFactory">Logger factory for creating loggers.</param>
|
|
public RealOpcUaClientFactory(OpcUaGlobalOptions globalOptions, ILoggerFactory loggerFactory)
|
|
{
|
|
_globalOptions = globalOptions;
|
|
_loggerFactory = loggerFactory;
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public IOpcUaClient Create() =>
|
|
new RealOpcUaClient(_globalOptions, _loggerFactory.CreateLogger<RealOpcUaClient>());
|
|
}
|