This commit is contained in:
EonaCat authored and Jeroen Saey committed 2026-11-04 07:53:40 +01:00
1 parent 2c5b69bf2c
commit 22dee59f47
132 files changed
+19653 -7192

No files matched your search

@@ -0,0 +1,44 @@
using EonaCat.Connections.OpcUa.Infrastructure;
using EonaCat.Connections.OpcUa.Models;
using Opc.Ua;
using Opc.Ua.Server;
namespace EonaCat.Connections.OpcUa.Server;
internal sealed class EonaCatOpcUaServer : StandardServer
{
private readonly string _namespaceUri;
private readonly IReadOnlyCollection<OpcUaNodeDefinition> _nodes;
private readonly IReadOnlyCollection<OpcUaMethodDefinition> _methods;
public EonaCatOpcUaServer(
string namespaceUri,
IReadOnlyCollection<OpcUaNodeDefinition> nodes,
IReadOnlyCollection<OpcUaMethodDefinition> methods)
: base(OpcUaRuntime.Telemetry)
{
_namespaceUri = namespaceUri;
_nodes = nodes;
_methods = methods;
}
public OpcUaAddressSpace? AddressSpace { get; private set; }
protected override MasterNodeManager CreateMasterNodeManager(
IServerInternal server,
ApplicationConfiguration configuration)
{
AddressSpace = new OpcUaAddressSpace(server, configuration, _namespaceUri, _nodes, _methods);
return new MasterNodeManager(server, configuration, null, AddressSpace);
}
protected override ServerProperties LoadServerProperties() => new()
{
ManufacturerName = "EonaCat",
ProductName = "EonaCat Generic OPC UA Server",
ProductUri = "urn:EonaCat:Connector:OpcUa",
SoftwareVersion = Utils.GetAssemblySoftwareVersion(),
BuildNumber = Utils.GetAssemblyBuildNumber(),
BuildDate = Utils.GetAssemblyTimestamp()
};
}
@@ -0,0 +1,197 @@
using EonaCat.Connections.OpcUa.Models;
using Opc.Ua;
using Opc.Ua.Server;
using System.Collections.Concurrent;
namespace EonaCat.Connections.OpcUa.Server;
internal sealed class OpcUaAddressSpace : CustomNodeManager2
{
private readonly IReadOnlyCollection<OpcUaNodeDefinition> _nodeDefinitions;
private readonly IReadOnlyCollection<OpcUaMethodDefinition> _methodDefinitions;
private readonly ConcurrentDictionary<string, BaseDataVariableState> _variables = new(StringComparer.Ordinal);
public OpcUaAddressSpace(
IServerInternal server,
ApplicationConfiguration configuration,
string namespaceUri,
IReadOnlyCollection<OpcUaNodeDefinition> nodeDefinitions,
IReadOnlyCollection<OpcUaMethodDefinition> methodDefinitions)
: base(server, configuration, namespaceUri)
{
_nodeDefinitions = nodeDefinitions;
_methodDefinitions = methodDefinitions;
SystemContext.NodeIdFactory = this;
}
public event EventHandler<OpcUaValueChangedEventArgs>? ValueChanged;
public override void CreateAddressSpace(IDictionary<NodeId, IList<IReference>> externalReferences)
{
lock (Lock)
{
if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out var references))
{
references = new List<IReference>();
externalReferences[ObjectIds.ObjectsFolder] = references;
}
var root = new FolderState(null)
{
NodeId = new NodeId("EonaCat", NamespaceIndex),
BrowseName = new QualifiedName("EonaCat", NamespaceIndex),
DisplayName = (LocalizedText)"EonaCat",
TypeDefinitionId = ObjectTypeIds.FolderType,
EventNotifier = EventNotifiers.None
};
root.AddReference(ReferenceTypeIds.Organizes, true, ObjectIds.ObjectsFolder);
references.Add(new NodeStateReference(ReferenceTypeIds.Organizes, false, root.NodeId));
foreach (var definition in _nodeDefinitions)
{
AddVariable(root, definition);
}
foreach (var definition in _methodDefinitions)
{
AddMethod(root, definition);
}
AddPredefinedNode(SystemContext, root);
}
}
public NodeId ResolveNodeId(string identifier) => new(identifier, NamespaceIndex);
public bool TrySetValue(string identifier, object? value)
{
if (!_variables.TryGetValue(identifier, out var variable))
{
return false;
}
lock (Lock)
{
variable.Value = new Variant(value);
variable.StatusCode = StatusCodes.Good;
variable.Timestamp = DateTime.UtcNow;
variable.ClearChangeMasks(SystemContext, false);
}
RaiseValueChanged(variable);
return true;
}
private void AddVariable(NodeState parent, OpcUaNodeDefinition definition)
{
var variable = new BaseDataVariableState(parent)
{
NodeId = ResolveNodeId(definition.Identifier),
BrowseName = new QualifiedName(definition.DisplayName, NamespaceIndex),
DisplayName = (LocalizedText)definition.DisplayName,
Description = (LocalizedText)definition.Description,
TypeDefinitionId = VariableTypeIds.BaseDataVariableType,
ReferenceTypeId = ReferenceTypeIds.HasComponent,
DataType = definition.DataType,
ValueRank = ValueRanks.Scalar,
AccessLevel = definition.AccessLevel,
UserAccessLevel = definition.AccessLevel,
Historizing = false,
Value = new Variant(definition.InitialValue),
StatusCode = StatusCodes.Good,
Timestamp = DateTime.UtcNow
};
variable.OnSimpleWriteValue = HandleWrite;
parent.AddChild(variable);
_variables[definition.Identifier] = variable;
}
private void AddMethod(NodeState parent, OpcUaMethodDefinition definition)
{
var method = new MethodState(parent)
{
NodeId = ResolveNodeId(definition.Identifier),
BrowseName = new QualifiedName(definition.DisplayName, NamespaceIndex),
DisplayName = (LocalizedText)definition.DisplayName,
Description = (LocalizedText)definition.Description,
ReferenceTypeId = ReferenceTypeIds.HasComponent,
Executable = true,
UserExecutable = true
};
method.InputArguments = CreateArguments(method, "InputArguments", definition.InputArguments);
method.OutputArguments = CreateArguments(method, "OutputArguments", definition.OutputArguments);
method.OnCallMethod = (_, _, inputArguments, outputArguments) =>
{
try
{
var inputs = new object?[inputArguments.Count];
for (var index = 0; index < inputs.Length; index++)
{
inputs[index] = inputArguments[index].Value;
}
var results = definition.Handler(inputs);
for (var index = 0; index < Math.Min(results.Count, outputArguments.Count); index++)
{
outputArguments[index] = new Variant(results[index]);
}
return ServiceResult.Good;
}
catch (Exception exception)
{
return new ServiceResult(exception, StatusCodes.BadUnexpectedError);
}
};
parent.AddChild(method);
}
private PropertyState<ArrayOf<Argument>> CreateArguments(
NodeState parent,
string name,
IReadOnlyList<OpcUaMethodArgument> definitions)
{
var property = PropertyState<ArrayOf<Argument>>.With<StructureBuilder<Argument>>(parent);
property.NodeId = new NodeId($"{parent.NodeId.Identifier}.{name}", NamespaceIndex);
property.BrowseName = (QualifiedName)(name == "InputArguments" ? BrowseNames.InputArguments : BrowseNames.OutputArguments);
property.DisplayName = (LocalizedText)name;
property.TypeDefinitionId = VariableTypeIds.PropertyType;
property.ReferenceTypeId = ReferenceTypeIds.HasProperty;
property.DataType = DataTypeIds.Argument;
property.ValueRank = ValueRanks.OneDimension;
property.Value = definitions.Select(definition => new Argument
{
Name = definition.Name,
DataType = definition.DataType,
ValueRank = ValueRanks.Scalar,
Description = (LocalizedText)definition.Description
}).ToArray();
return property;
}
private ServiceResult HandleWrite(ISystemContext context, NodeState node, ref Variant value)
{
if (node is not BaseDataVariableState variable || (variable.AccessLevel & AccessLevels.CurrentWrite) == 0)
{
return StatusCodes.BadNotWritable;
}
variable.Value = value;
variable.Timestamp = DateTime.UtcNow;
variable.StatusCode = StatusCodes.Good;
RaiseValueChanged(variable);
return ServiceResult.Good;
}
private void RaiseValueChanged(BaseDataVariableState variable)
{
ValueChanged?.Invoke(this, new OpcUaValueChangedEventArgs
{
NodeId = variable.NodeId,
Value = variable.Value.Value,
StatusCode = variable.StatusCode,
SourceTimestamp = variable.Timestamp.ToDateTime()
});
}
}
@@ -0,0 +1,170 @@
using EonaCat.Connections.OpcUa.Configuration;
using EonaCat.Connections.OpcUa.Infrastructure;
using EonaCat.Connections.OpcUa.Models;
using Opc.Ua;
using Opc.Ua.Configuration;
namespace EonaCat.Connections.OpcUa.Server;
public sealed class OpcUaNetworkServer : IAsyncDisposable, IDisposable
{
private readonly OpcUaServerOptions _options;
private readonly List<OpcUaNodeDefinition> _nodes = [];
private readonly List<OpcUaMethodDefinition> _methods = [];
private readonly SemaphoreSlim _lifecycleLock = new(1, 1);
private ApplicationInstance? _application;
private EonaCatOpcUaServer? _server;
private bool _disposed;
public OpcUaNetworkServer(OpcUaServerOptions options)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
}
public bool IsStarted { get; private set; }
public string EndpointUrl => _options.BaseAddress;
public string NamespaceUri => _options.NamespaceUri;
public event EventHandler? Started;
public event EventHandler? Stopped;
public event EventHandler<OpcUaValueChangedEventArgs>? ValueChanged;
public event EventHandler<Exception>? Error;
public OpcUaNetworkServer AddVariable(OpcUaNodeDefinition definition)
{
EnsureNotStarted();
ArgumentNullException.ThrowIfNull(definition);
if (_nodes.Any(node => string.Equals(node.Identifier, definition.Identifier, StringComparison.Ordinal)))
{
throw new ArgumentException($"A node with identifier '{definition.Identifier}' is already registered.", nameof(definition));
}
_nodes.Add(definition);
return this;
}
public OpcUaNetworkServer AddMethod(OpcUaMethodDefinition definition)
{
EnsureNotStarted();
ArgumentNullException.ThrowIfNull(definition);
if (_methods.Any(method => string.Equals(method.Identifier, definition.Identifier, StringComparison.Ordinal)))
{
throw new ArgumentException($"A method with identifier '{definition.Identifier}' is already registered.", nameof(definition));
}
_methods.Add(definition);
return this;
}
public async Task StartAsync(CancellationToken cancellationToken = default)
{
await _lifecycleLock.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
ObjectDisposedException.ThrowIf(_disposed, this);
if (IsStarted)
{
return;
}
var configuration = await OpcUaApplicationConfigurationFactory
.CreateServerAsync(_options, cancellationToken)
.ConfigureAwait(false);
_server = new EonaCatOpcUaServer(_options.NamespaceUri, _nodes.ToArray(), _methods.ToArray());
_application = new ApplicationInstance(OpcUaRuntime.Telemetry)
{
ApplicationName = _options.ApplicationName,
ApplicationType = ApplicationType.Server,
ApplicationConfiguration = configuration
};
await _application.StartAsync(_server).ConfigureAwait(false);
if (_server.AddressSpace != null)
{
_server.AddressSpace.ValueChanged += HandleValueChanged;
}
IsStarted = true;
Started?.Invoke(this, EventArgs.Empty);
}
catch (Exception exception)
{
Error?.Invoke(this, exception);
throw;
}
finally
{
_lifecycleLock.Release();
}
}
public NodeId GetNodeId(string identifier)
{
ArgumentException.ThrowIfNullOrWhiteSpace(identifier);
return _server?.AddressSpace?.ResolveNodeId(identifier)
?? throw new InvalidOperationException("The OPC UA server has not started.");
}
public bool TrySetValue(string identifier, object? value)
{
ArgumentException.ThrowIfNullOrWhiteSpace(identifier);
return _server?.AddressSpace?.TrySetValue(identifier, value) == true;
}
public async Task StopAsync(CancellationToken cancellationToken = default)
{
await _lifecycleLock.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
if (!IsStarted)
{
return;
}
if (_server?.AddressSpace != null)
{
_server.AddressSpace.ValueChanged -= HandleValueChanged;
}
if (_application != null)
{
await _application.StopAsync().ConfigureAwait(false);
}
_server?.Dispose();
_server = null;
_application = null;
IsStarted = false;
Stopped?.Invoke(this, EventArgs.Empty);
}
finally
{
_lifecycleLock.Release();
}
}
private void HandleValueChanged(object? sender, OpcUaValueChangedEventArgs args) =>
ValueChanged?.Invoke(this, args);
private void EnsureNotStarted()
{
ObjectDisposedException.ThrowIf(_disposed, this);
if (IsStarted)
{
throw new InvalidOperationException("Nodes and methods must be registered before the OPC UA server starts.");
}
}
public async ValueTask DisposeAsync()
{
if (_disposed)
{
return;
}
await StopAsync().ConfigureAwait(false);
_disposed = true;
_lifecycleLock.Dispose();
}
public void Dispose() => DisposeAsync().AsTask().GetAwaiter().GetResult();
}