I have an idea to model static parts (parts that are the same across all controllers) of a controller in a ModelDesign.xml file to utlize the framework as much as possible. As I understand it you get a lot out of the box (such as browsing) and support by the partial generated classes where you can put your implementation code. The static parts are not too extensive and can be cached in PredefinedNodes or similar.

Then treat the dynamic parts (parts that differ from controller to controller) more like the MemoryBuffer with no or sparse caching and custom browsing.  The question is how I can best achieve this? Same or different nodemanager for the two parts? Which nodemanager to use/start off from? Represent dynamic parts with NodeState-derived classes (like MemoryTagState) or custom lightweight classes? Are there cases where it is a good idea to skip using NodeState-derived classes?

I'm getting a bit confused by all different examples, and I find it difficult to become any wiser by reading the documentation. I can't find a user-friendly documentation which can guide me in the correct direction. There are som many different examples starting off from different nodemanager classes or interfaces (CustomNodeManger2, SampleNodeManager, INodeManager, INodeManager2...). It is difficult to get a clear view of the differences between the different nodemanagers. Seems like a tedious task to implement a nodemanager interface from scratch. Dynamic data is sometimes represented by NodeState and somtimes by custom lightweight classes. And so on...

I would really appreciate some help!    

Disclosure first: I am the author of node-opcua and I work at Sterfive, which makes one of the tools below.

1. The OPC Foundation now has its own editor. The UA NodeSet Editor (https://uanodeseteditor.opcfou.....ation.org/) is a free web tool to create and edit information models, start from the UA Cloud Library, and export a NodeSet. It can also check a Companion Specification Word document against its NodeSet. Source: https://github.com/OPCFoundati.....eSetEditor

2. UA-ModelCompiler is still the way to go if you need the generated C# or ANSI C classes the original question was about. Stefan's tutorial above remains a good introduction.

3. If what you need is the NodeSet2.xml itself, another approach is to write the model as text and compile it. That is what we built: OPC UA Modeler takes a small YAML description and generates a standard NodeSet2.xml, with the companion specifications (DI, Machinery, Robotics…) available by alias and the model validated as you type. Because the model is a text file, it diffs, reviews and merges like source code, and can be built in CI.

namespaceUri: http://acme.example/UA/Pump/
version: 1.0.0

namespaces:
- di

objectTypes:
- browseName: PumpType
  subtypeOf: di:DeviceType
  components:
  - browseName: di:ParameterSet
    components:
    - browseName: FlowRate
      dataType: ua:Double

To be clear about its limits: it produces NodeSet2.xml, not ModelDesign XML, and it does not generate C# classes. The .NET Standard stack, open62541, node-opcua and the other SDKs load the resulting NodeSet2.xml directly.

The language specification (CC BY 4.0), its JSON Schema and example models are public: https://github.com/node-opcua/.....ua-modeler
A tool-neutral walkthrough of what a NodeSet2.xml contains and the different ways to produce one: https://opcua-modeler.doc.ster.....deset2-xml

Etienne

happy to hear that you started working with the CTT to test your product. I assume your problem is something very basic like that the setting has not been stored in the configuration yet, since you haven't clicked on "Apply". You'll find the "Apply" button at the bottom of the settings dialog. Once you applied the configuration change with the endpoint URL the connection should be working fine.

If you are then still facing issues. Please let me know.

Regards,
Alexander Allmendinger

I'm trying to start a project om CTT, but when I add my Server URL i only receive back No endpoints discovered. The same server works well via UAExpert. Any possible causes and solutions?

Not every client will look for it but it is required if you are returning exchanging instances over the wire.

Specification is fairly clear:

https://reference.opcfoundatio.....erences%2E

We already tested with UAExpert and with that tool we are able to execute the method call. However according to Siemens the method call executed by Opcenter Execution MOM fails because our custom created 'DataType -> BaseDataType -> Structure -> FieldObject' does not return HasEncoding. This is also confirmed when browsing to FieldObject with UAExpert.

Because we now have internally a discussion in whether or not the problem is on the OPC-UA server side or in Siemens Opcenter Connect MOM I wanted to use the UACTT Lite test tool so that it maybe would confirm the feedback of Siemens that the OPC-UA Server is not compliant to the standard.

Is it possible to also answer my initial question if it is possible to test an OPC-UA method call with UACTT Lite?

Regards,

Erik

If that works it is client side issue.

The issue is you have likely created a DataType Node which is used as an argument in the Method.

This DataType Node needs to have an associated DataTypeEncoding Node. If your Server does not return a HasEncoding reference when the DataType is browsed then that would explain the issue.

To validate if our OPC-UA server is compliant with the OPC-UA standard I started testing with the 'UACTT Lite' test tool. However as soon as I try to execute a method call test script I get the error CallService does not exist. After some digging I discovered that I do not have the Call.js file which should be in the following location according to the documentation which is included with the 'UACTT Lite' test tool:

Location: /project>/library/Base/ServiceBased/MethodServiceSet/Call.js

So now I'm wondering is it even possible to test an OPC-UA method call with UACTT Lite or is this only supported in the full version?

Any help is appreciated.

Regards,

Erik

*.Classes.cs is server only.

My understanding is that the Model Compiler will generate classes for UA datatypes, and also for object types and variable types.

And I can use the datatypes classes on both the server side and client side (in my case with the .NET stack/SDK).

But the object type and variable type classes are for server side only, right? For them, there is nothing generated for client side, right?

Thanks for clarification.

The understand the value of this approach you must see a UA information model as a window on your data rather than a database.

What this means is you do not need represent a device as 10+ nodes in memory. You instead build a NodeId structure that allows to response to Browse/Read/Write/Call on demand.

This means the only thing you actually need in memory is a structure that describes your device. All of the information associated with various Nodes used to represent your device are collected on demand by merging the static model with the device specific data..

To illustrate this concept a NodeManager for 100 million Nodes was implemented here:

https://github.com/OPCFoundati.....moryBuffer

We are developing an OPC UA server based on on the library 'OPCFoundation.NetStandard.Opc.Ua.Server'. The server exposes data of building automation controllers (up to 500 devices). We are now a bit worried that the address space will take up too much RAM, since each object is represented by a number of nodes that must be stored in memory.

What generally consumes the most memory in an OPC UA server? Is it the storage of the address space, or other factors such as subscriptions and monitored items?

Please guide us regarding memory consumption in an OPC UA server. Maybe we're worrying about nothing?

How we are currently working:

We model our object types in a ModelDesign.xml file and then compile it with ModelCompiler. Then we load the .uanodes file generated by the compiler in our node manager class. To add an object (set of nodes) to the address space of the server we create an object instance of one of the classes that are generated by the compiler and then call CreateNode with that instance as inparameter (we also create references). As we understand the address space (all nodes) are cached in CustomNodeManager2::m_predefinedNodes.

Was working fine with anonymous/basic auth during local testing, but I'm running into failures now trying to connect to a customer OPC UA server leveraging certificates.

Looking for any guidance, as both this auth problem and certificate problems in general are a little out of my depth.

I am not using an XML config for the application configuration, I have most of it hard coded with some choices exposed through default ASP.NET Core `IConfiguration`.

I thought that using a single certificate would be better than allowing the application to generate its own on session handshake, so I used an F# script to generate a certificate and provided the `pem` and `der` to the customer to add to the `trusted` folder of their OPC UA server. I'm pulling in the `.pfx` file to use during the handshake.

Any help or guidance towards documentation/examples to help me resolve this problem would be greatly appreciated!

Here is the log message/exception that I'm getting:
```
info: ReachPapermakingClient.OpcUaClientFactoryV2[0]
Loaded OPC UA client certificate: Subject=CN=ProjectName, O=CompanyName, OU=OPC UA Client, Thumbprint=12345abcdefg, ValidTo=04/13/2036 10:44:59
info: ReachPapermakingClient.OpcUaClientFactoryV2[0]
OPC UA application configuration validated

info: ReachPapermakingClient.OpcUaClientFactoryV2[0]
Connecting: Endpoint=opc.tcp://myendpoint.com:4840, Session=REACH_Papermaking_Client_Primary, Auth=Username (opc_test)

info: ReachPapermakingClient.OpcUaClientFactoryV2[0]
Selected endpoint: opc.tcp://myendpoint.com:4840, SecurityPolicy=https://opcfoundation.org/UA/SecurityPolicy#Aes256_Sha256_RsaPss, SecurityMode=SignAndEncrypt

info: ReachPapermakingClient.OpcUaClientFactoryV2[0]
Using username/password identity for user: opc_test

Unhandled exception. Opc.Ua.ServiceResultException: ApplicationCertificate for the security profile https://opcfoundation.org/UA/SecurityPolicy#Aes256_Sha256_RsaPss cannot be found.
at Opc.Ua.Client.Session.LoadCertificateAsync(ApplicationConfiguration configuration, String securityProfile)
at Opc.Ua.Client.Session.CreateChannelAsync(ApplicationConfiguration configuration,
ITransportWaitingConnection connection, ConfiguredEndpoint endpoint, Boolean updateBeforeConnect, Boolean checkDomain, CancellationToken ct)
at Opc.Ua.Client.Session.CreateAsync(ISessionInstantiator sessionInstantiator, ApplicationConfiguration configuration, ITransportWaitingConnection connection, ConfiguredEndpoint endpoint, Boolean updateBeforeConnect, Boolean checkDomain, String sessionName, UInt32 sessionTimeout, IUserIdentity identity, IList`1 preferredLocales, CancellationToken ct)
at Opc.Ua.Client.DefaultSessionFactory.CreateAsync(ApplicationConfiguration configuration, ConfiguredEndpoint endpoint, Boolean updateBeforeConnect, Boolean checkDomain, String sessionName, UInt32 sessionTimeout, IUserIdentity identity, IList`1 preferredLocales, CancellationToken ct)
at Opc.Ua.Client.TraceableSessionFactory.CreateAsync(ApplicationConfiguration configuration, ConfiguredEndpoint endpoint, Boolean updateBeforeConnect, String sessionName, UInt32 sessionTimeout, IUserIdentity identity, IList`1 preferredLocales, CancellationToken ct)
at ReachPapermakingClient.OpcUaClientFactoryV2.CreateClientAsync(ApplicationConfiguration config, String endpointUrl, String sessionName) in D:\agent\_work\3348\s\OpcUa\OpcUaClientFactoryV2.cs:line 206
at ReachPapermakingClient.OpcUaClientFactoryV2.CreateRedundantOpcUaClient(String sessionName, ILogger`1 logger) in D:\agent\_work\3348\s\OpcUa\OpcUaClientFactoryV2.cs:line 58
at Program.<Main>$(String[] args) in D:\agent\_work\3348\s\Worker\Program.cs:line 74
at Program.<Main>(String[] args)
Aborted
```

Here is the application configuration that I'm using to build out the OPC UA Client:
```cs
private ApplicationConfiguration BuildApplicationConfiguration()
{
var certificate = LoadClientCertificate();

return new ApplicationConfiguration
{
ApplicationName = ApplicationName,
ApplicationUri = ApplicationUri,
ApplicationType = ApplicationType.Client,
SecurityConfiguration = new SecurityConfiguration
{
ApplicationCertificate = new CertificateIdentifier
{
StoreType = "Directory",
StorePath = GetCertificateStorePath("own"),
SubjectName = certificate.Subject,
Certificate = certificate
},
AutoAcceptUntrustedCertificates = true,
RejectSHA1SignedCertificates = false,
RejectUnknownRevocationStatus = false,
AddAppCertToTrustedStore = true,
TrustedPeerCertificates = new CertificateTrustList
{
StoreType = "Directory",
StorePath = GetCertificateStorePath("trusted")
},
TrustedIssuerCertificates = new CertificateTrustList
{
StoreType = "Directory",
StorePath = GetCertificateStorePath("issuer")
},
RejectedCertificateStore = new CertificateStoreIdentifier
{
StoreType = "Directory",
StorePath = GetCertificateStorePath("rejected")
}
},
TransportConfigurations = new TransportConfigurationCollection(),
TransportQuotas = new TransportQuotas { OperationTimeout = 30_000 },
ClientConfiguration = new ClientConfiguration { DefaultSessionTimeout = 60_000 },
};
}
```

Here is the F# script that is used to create the cert that we're using (in case we need to embed the security profile in the generation somehow? Again, i have no idea here)

```fs
let applicationName = "REACH_Papermaking"
let applicationUri = "urn:REACH_Papermaking:OpcUaClient"
let subjectName = "CN=ProjectName, O=CompanyName, OU=OPC UA Client"

let outputDir =
let dir = Path.Combine(__SOURCE_DIRECTORY__, "..", "Worker", "Certificates")
let dir = Path.GetFullPath(dir)
Directory.CreateDirectory(dir) |> ignore
dir

let lifetimeMonths = uint16 (10 * 12)

let cert =
CertificateFactory
.CreateCertificate(applicationUri, applicationName, subjectName, null)
.SetNotBefore(DateTime.UtcNow.AddDays(-1.0))
.SetLifeTime(lifetimeMonths)
.SetHashAlgorithm(X509Utils.GetRSAHashAlgorithmName(uint32 CertificateFactory.DefaultHashSize))
.SetRSAKeySize(CertificateFactory.DefaultKeySize)
.CreateForRSA()

let derPath = Path.Combine(outputDir, $"{applicationName}.der")
File.WriteAllBytes(derPath, cert.RawData)
let pfxPath = Path.Combine(outputDir, $"{applicationName}.pfx")
File.WriteAllBytes(pfxPath, cert.Export(X509ContentType.Pfx))
let pemPath = Path.Combine(outputDir, $"{applicationName}.pem")
File.WriteAllText(pemPath, cert.ExportCertificatePem())

exit 0
```

Just wanted to add an option that wasn't available back in 2016: php-opcua (https://www.php-opcua.com/) is a pure-PHP OPC UA client that works on Linux with no native extensions required — just composer require php-opcua/opcua-client.

It supports read/write, browse, subscriptions, and 10 security policies, and has dedicated packages for Laravel and Symfony. MIT licensed and open source.

Should be a good fit for the Linux use case mentioned in this thread.

Cheers