Add support for private encodeable factory in server initialization (#3366)

* Initial plan

* Add support for private encodeable factory in server initialization

- Add new ServiceMessageContext constructor that accepts a custom IEncodeableFactory
- Add CreateMessageContext(IEncodeableFactory) overload to ApplicationConfiguration
- Mark CreateMessageContext(bool) as obsolete since the clonedFactory parameter was never used
- Add PrivateEncodeableFactory property to ServerBase for specifying a private factory
- Update all internal calls to use the new parameterless CreateMessageContext()

Co-authored-by: romanett <[email protected]>

* Add unit tests for ServiceMessageContext private factory support

Co-authored-by: romanett <[email protected]>

* Improve documentation for ServiceMessageContext constructors

Co-authored-by: romanett <[email protected]>

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: romanett <[email protected]>

Author: Copilot

Libraries/Opc.Ua.Client/Session/DefaultSessionFactory.cs

@@ -232,7 +232,7 @@ public virtual async Task<ITransportChannel> CreateChannelAsync(
             }
 
             // create message context.
-            ServiceMessageContext messageContext = configuration.CreateMessageContext(true);
+            ServiceMessageContext messageContext = configuration.CreateMessageContext();
 
             // update endpoint description using the discovery endpoint.
             if (endpoint.UpdateBeforeConnect && connection == null)

Libraries/Opc.Ua.Client/Session/Session.cs

@@ -110,7 +110,7 @@ public Session(
                   channel,
                   configuration,
                   endpoint,
-                  channel.MessageContext ?? configuration.CreateMessageContext(true))
+                  channel.MessageContext ?? configuration.CreateMessageContext())
         {
             m_instanceCertificate = clientCertificate;
             m_instanceCertificateChain = clientCertificateChain;
@@ -129,7 +129,7 @@ public Session(ITransportChannel channel, Session template, bool copyEventHandle
                   channel,
                   template.m_configuration,
                   template.ConfiguredEndpoint,
-                  channel.MessageContext ?? template.m_configuration.CreateMessageContext(true))
+                  channel.MessageContext ?? template.m_configuration.CreateMessageContext())
         {
             m_instanceCertificate = template.m_instanceCertificate;
             m_instanceCertificateChain = template.m_instanceCertificateChain;

Libraries/Opc.Ua.Gds.Client.Common/GlobalDiscoveryServerClient.cs

@@ -57,7 +57,7 @@ public GlobalDiscoveryServerClient(
             DiagnosticsMasks diagnosticsMasks = DiagnosticsMasks.None)
         {
             Configuration = configuration;
-            MessageContext = configuration.CreateMessageContext(true);
+            MessageContext = configuration.CreateMessageContext();
             m_logger = MessageContext.Telemetry.CreateLogger<GlobalDiscoveryServerClient>();
             m_sessionFactory = sessionFactory ??
                 new DefaultSessionFactory(MessageContext.Telemetry)

Libraries/Opc.Ua.Gds.Client.Common/ServerPushConfigurationClient.cs

@@ -55,7 +55,7 @@ public ServerPushConfigurationClient(
             DiagnosticsMasks diagnosticsMasks = DiagnosticsMasks.None)
         {
             Configuration = configuration;
-            MessageContext = configuration.CreateMessageContext(true);
+            MessageContext = configuration.CreateMessageContext();
             m_logger = MessageContext.Telemetry.CreateLogger<ServerPushConfigurationClient>();
             m_sessionFactory = sessionFactory ??
                 new DefaultSessionFactory(MessageContext.Telemetry)

Stack/Opc.Ua.Core/Stack/Configuration/ApplicationConfiguration.cs

@@ -172,10 +172,31 @@ public IList<string> GetServerDomainNames()
         /// <summary>
         /// Creates the message context from the configuration.
         /// </summary>
+        /// <param name="clonedFactory">This parameter is obsolete and ignored. A new factory instance is always created.</param>
         /// <returns>A new instance of a ServiceMessageContext object.</returns>
-        public ServiceMessageContext CreateMessageContext(bool clonedFactory = false)
+        [Obsolete("Use CreateMessageContext() without parameters or CreateMessageContext(IEncodeableFactory) instead.")]
+        public ServiceMessageContext CreateMessageContext(bool clonedFactory)
         {
-            var messageContext = new ServiceMessageContext(m_telemetry);
+            return CreateMessageContext((IEncodeableFactory)null);
+        }
+
+        /// <summary>
+        /// Creates the message context from the configuration.
+        /// </summary>
+        /// <returns>A new instance of a ServiceMessageContext object with a new encodeable factory.</returns>
+        public ServiceMessageContext CreateMessageContext()
+        {
+            return CreateMessageContext((IEncodeableFactory)null);
+        }
+
+        /// <summary>
+        /// Creates the message context from the configuration with a private encodeable factory.
+        /// </summary>
+        /// <param name="factory">The private encodeable factory to use. If null, a new factory will be created.</param>
+        /// <returns>A new instance of a ServiceMessageContext object.</returns>
+        public ServiceMessageContext CreateMessageContext(IEncodeableFactory factory)
+        {
+            var messageContext = new ServiceMessageContext(m_telemetry, factory);
 
             if (TransportQuotas != null)
             {

Stack/Opc.Ua.Core/Stack/Server/ServerBase.cs

@@ -701,6 +701,22 @@ protected class BaseAddress
         /// <value>The provider for the X.509 certificates.</value>
         public CertificateTypesProvider InstanceCertificateTypesProvider { get; private set; }
 
+        /// <summary>
+        /// Gets or sets the private encodeable factory to use for this server instance.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// Set this property before calling <see cref="StartAsync(ApplicationConfiguration, CancellationToken, Uri[])"/>
+        /// or <see cref="StartAsync(ApplicationConfiguration, CancellationToken)"/> to use a private factory
+        /// that is isolated from other servers and clients in the same process.
+        /// </para>
+        /// <para>
+        /// If this property is null (the default), a new factory will be created
+        /// during server startup via <see cref="EncodeableFactory.Create()"/>.
+        /// </para>
+        /// </remarks>
+        public IEncodeableFactory PrivateEncodeableFactory { get; set; }
+
         /// <summary>
         /// The non-configurable properties for the server.
         /// </summary>
@@ -1363,8 +1379,8 @@ protected virtual void OnServerStarting(ApplicationConfiguration configuration)
         {
             // use the message context from the configuration to ensure the channels are
             // using the same one. This also sets the telemetry context for the server
-            // from configuration.
-            ServiceMessageContext messageContext = configuration.CreateMessageContext(true);
+            // from configuration. If a private factory was specified, use it.
+            ServiceMessageContext messageContext = configuration.CreateMessageContext(PrivateEncodeableFactory);
             messageContext.NamespaceUris = new NamespaceTable();
             MessageContext = messageContext;
 

Stack/Opc.Ua.Types/Utils/ServiceMessageContext.cs

@@ -46,9 +46,25 @@ public ServiceMessageContext()
         }
 
         /// <summary>
-        /// Initializes the object with default values.
+        /// Initializes the object with default values and a new encodeable factory.
         /// </summary>
+        /// <param name="telemetry">The telemetry context to use to create observability instruments.</param>
+        /// <remarks>
+        /// A new <see cref="IEncodeableFactory"/> instance is created via <see cref="EncodeableFactory.Create()"/>.
+        /// To use a private factory that is isolated from other instances in the same process,
+        /// use <see cref="ServiceMessageContext(ITelemetryContext, IEncodeableFactory)"/> instead.
+        /// </remarks>
         public ServiceMessageContext(ITelemetryContext telemetry)
+            : this(telemetry, null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes the object with default values and an optional private encodeable factory.
+        /// </summary>
+        /// <param name="telemetry">The telemetry context to use to create observability instruments.</param>
+        /// <param name="factory">The private encodeable factory to use. If null, a new factory will be created.</param>
+        public ServiceMessageContext(ITelemetryContext telemetry, IEncodeableFactory factory)
         {
             Telemetry = telemetry;
             MaxStringLength = DefaultEncodingLimits.MaxStringLength;
@@ -59,7 +75,7 @@ public ServiceMessageContext(ITelemetryContext telemetry)
             MaxDecoderRecoveries = DefaultEncodingLimits.MaxDecoderRecoveries;
             m_namespaceUris = new NamespaceTable();
             m_serverUris = new StringTable();
-            m_factory = EncodeableFactory.Create();
+            m_factory = factory ?? EncodeableFactory.Create();
         }
 
         /// <summary>

Tests/Opc.Ua.Core.Tests/Types/Utils/ServiceMessageContextTests.cs

@@ -0,0 +1,139 @@
+/* ========================================================================
+ * Copyright (c) 2005-2024 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 NUnit.Framework;
+using Assert = NUnit.Framework.Legacy.ClassicAssert;
+
+namespace Opc.Ua.Core.Tests.Types.ServiceMessageContextTests
+{
+    /// <summary>
+    /// Tests for <see cref="ServiceMessageContext"/>.
+    /// </summary>
+    [TestFixture]
+    [Category("ServiceMessageContext")]
+    [Parallelizable]
+    public class ServiceMessageContextTests
+    {
+        /// <summary>
+        /// Test that creating a ServiceMessageContext with a null factory creates a new factory.
+        /// </summary>
+        [Test]
+        public void ConstructorWithNullFactoryCreatesNewFactory()
+        {
+            // Arrange & Act
+            var context = new ServiceMessageContext((ITelemetryContext)null, (IEncodeableFactory)null);
+
+            // Assert
+            Assert.IsNotNull(context.Factory);
+        }
+
+        /// <summary>
+        /// Test that creating a ServiceMessageContext with a custom factory uses that factory.
+        /// </summary>
+        [Test]
+        public void ConstructorWithCustomFactoryUsesProvidedFactory()
+        {
+            // Arrange
+            IEncodeableFactory customFactory = EncodeableFactory.Create();
+
+            // Act
+            var context = new ServiceMessageContext(null, customFactory);
+
+            // Assert
+            Assert.AreSame(customFactory, context.Factory);
+        }
+
+        /// <summary>
+        /// Test that two ServiceMessageContexts with different factories have separate factories.
+        /// </summary>
+        [Test]
+        public void TwoContextsWithDifferentFactoriesAreSeparate()
+        {
+            // Arrange
+            IEncodeableFactory factory1 = EncodeableFactory.Create();
+            IEncodeableFactory factory2 = EncodeableFactory.Create();
+
+            var context1 = new ServiceMessageContext(null, factory1);
+            var context2 = new ServiceMessageContext(null, factory2);
+
+            // Assert - the contexts should reference different factory instances
+            Assert.AreSame(factory1, context1.Factory);
+            Assert.AreSame(factory2, context2.Factory);
+            Assert.AreNotSame(context1.Factory, context2.Factory);
+        }
+
+        /// <summary>
+        /// Test that the default constructor creates a new factory.
+        /// </summary>
+        [Test]
+        public void DefaultConstructorCreatesNewFactory()
+        {
+            // Arrange & Act
+            var context = new ServiceMessageContext(null);
+
+            // Assert
+            Assert.IsNotNull(context.Factory);
+        }
+
+        /// <summary>
+        /// Test that setting the Factory property works correctly.
+        /// </summary>
+        [Test]
+        public void SettingFactoryPropertyWorks()
+        {
+            // Arrange
+            var context = new ServiceMessageContext(null);
+            IEncodeableFactory customFactory = EncodeableFactory.Create();
+
+            // Act
+            context.Factory = customFactory;
+
+            // Assert
+            Assert.AreSame(customFactory, context.Factory);
+        }
+
+        /// <summary>
+        /// Test that setting the Factory property to null creates a new factory.
+        /// </summary>
+        [Test]
+        public void SettingFactoryPropertyToNullCreatesNewFactory()
+        {
+            // Arrange
+            var context = new ServiceMessageContext(null);
+            var originalFactory = context.Factory;
+
+            // Act
+            context.Factory = null;
+
+            // Assert
+            Assert.IsNotNull(context.Factory);
+            Assert.AreNotSame(originalFactory, context.Factory);
+        }
+    }
+}