Fix reopen secure channel without activate

Applications/ConsoleReferenceClient/ClientSamples.cs

@@ -699,7 +699,7 @@ public void SubscribeToDataChanges(ISession session, uint minLifeTime)
         /// Outputs elapsed time information for perf testing and lists all
         /// types that were successfully added to the session encodeable type factory.
         /// </remarks>
-        public async Task LoadTypeSystemAsync(ISession session)
+        public async Task<ComplexTypeSystem> LoadTypeSystemAsync(ISession session)
         {
             m_output.WriteLine("Load the server type system.");
 
@@ -732,6 +732,8 @@ public async Task LoadTypeSystemAsync(ISession session)
                     }
                 }
             }
+
+            return complexTypeSystem;
         }
         #endregion
 
@@ -900,7 +902,7 @@ Task FetchReferenceIdTypesAsync(ISession session)
                         StartNodeId = item.NodeId,
                         AttributeId = Attributes.Value,
                         SamplingInterval = samplingInterval,
-                        DisplayName = item.DisplayName?.Text ?? item.BrowseName.Name,
+                        DisplayName = item.DisplayName?.Text ?? item.BrowseName?.Name ?? "unknown",
                         QueueSize = queueSize,
                         DiscardOldest = true,
                         MonitoringMode = MonitoringMode.Reporting,

Applications/ConsoleReferenceClient/Program.cs

@@ -234,7 +234,7 @@ public static async Task Main(string[] args)
                             var samples = new ClientSamples(output, ClientBase.ValidateResponse, quitEvent, verbose);
                             if (loadTypes)
                             {
-                                await samples.LoadTypeSystemAsync(uaClient.Session).ConfigureAwait(false);
+                                var complexTypeSystem = await samples.LoadTypeSystemAsync(uaClient.Session).ConfigureAwait(false);
                             }
 
                             if (browseall || fetchall || jsonvalues)
@@ -266,8 +266,8 @@ public static async Task Main(string[] args)
 
                                 if (subscribe && (browseall || fetchall))
                                 {
-                                    // subscribe to 100 random variables
-                                    const int MaxVariables = 100;
+                                    // subscribe to 1000 random variables
+                                    const int MaxVariables = 1000;
                                     NodeCollection variables = new NodeCollection();
                                     Random random = new Random(62541);
                                     if (fetchall)
@@ -291,15 +291,41 @@ public static async Task Main(string[] args)
 
                                     await samples.SubscribeAllValuesAsync(uaClient,
                                         variableIds: new NodeCollection(variables),
-                                        samplingInterval: 1000,
-                                        publishingInterval: 5000,
+                                        samplingInterval: 100,
+                                        publishingInterval: 1000,
                                         queueSize: 10,
-                                        lifetimeCount: 12,
+                                        lifetimeCount: 60,
                                         keepAliveCount: 2).ConfigureAwait(false);
 
                                     // Wait for DataChange notifications from MonitoredItems
                                     output.WriteLine("Subscribed to {0} variables. Press Ctrl-C to exit.", MaxVariables);
-                                    quit = quitEvent.WaitOne(timeout > 0 ? waitTime : Timeout.Infinite);
+
+                                    // free unused memory
+                                    uaClient.Session.NodeCache.Clear();
+
+                                    waitTime = timeout - (int)DateTime.UtcNow.Subtract(start).TotalMilliseconds;
+                                    DateTime endTime = waitTime > 0 ? DateTime.UtcNow.Add(TimeSpan.FromMilliseconds(waitTime)) : DateTime.MaxValue;
+                                    var variableIterator = variables.GetEnumerator();
+                                    while (!quit && endTime > DateTime.UtcNow)
+                                    {
+                                        if (variableIterator.MoveNext())
+                                        {
+                                            try
+                                            {
+                                                var value = await uaClient.Session.ReadValueAsync(variableIterator.Current.NodeId).ConfigureAwait(false);
+                                                output.WriteLine("Value of {0} is {1}", variableIterator.Current.NodeId, value);
+                                            }
+                                            catch (Exception ex)
+                                            {
+                                                output.WriteLine("Error reading value of {0}: {1}", variableIterator.Current.NodeId, ex.Message);
+                                            }
+                                        }
+                                        else
+                                        {
+                                            variableIterator = variables.GetEnumerator();
+                                        }
+                                        quit = quitEvent.WaitOne(500);
+                                    }
                                 }
                                 else
                                 {

Libraries/Opc.Ua.Client/Session.cs

@@ -27,6 +27,10 @@
  * http://opcfoundation.org/License/MIT/1.00/
  * ======================================================================*/
 
+#if NET6_0_OR_GREATER
+#define PERIODIC_TIMER
+#endif
+
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -40,6 +44,7 @@
 using System.Threading.Tasks;
 using System.Xml;
 using Microsoft.Extensions.Logging;
+using Opc.Ua.Bindings;
 
 namespace Opc.Ua.Client
 {
@@ -741,17 +746,25 @@
         /// Returns true if the session is not receiving keep alives.
         /// </summary>
         /// <remarks>
-        /// Set to true if the server does not respond for 2 times the KeepAliveInterval.
-        /// Set to false is communication recovers.
+        /// Set to true if the server does not respond for 2 times the KeepAliveInterval
+        /// or if another error was reported.
+        /// Set to false is communication is ok or recovered.
         /// </remarks>
         public bool KeepAliveStopped
         {
             get
             {
-                TimeSpan delta = TimeSpan.FromTicks(DateTime.UtcNow.Ticks - Interlocked.Read(ref m_lastKeepAliveTime));
+                StatusCode lastKeepAliveErrorStatusCode = m_lastKeepAliveErrorStatusCode;
+                if (StatusCode.IsGood(lastKeepAliveErrorStatusCode) || lastKeepAliveErrorStatusCode == StatusCodes.BadNoCommunication)
+                {
+                    TimeSpan delta = TimeSpan.FromTicks(DateTime.UtcNow.Ticks - Interlocked.Read(ref m_lastKeepAliveTime));
 
-                // add a guard band to allow for network lag.
-                return (m_keepAliveInterval + kKeepAliveGuardBand) <= delta.TotalMilliseconds;
+                    // add a guard band to allow for network lag.
+                    return (m_keepAliveInterval + kKeepAliveGuardBand) <= delta.TotalMilliseconds;
+                }
+
+                // another error was reported which caused keep alive to stop.
+                return true;
             }
         }
 
@@ -1429,7 +1442,10 @@
 
                 if (!result.AsyncWaitHandle.WaitOne(kReconnectTimeout / 2))
                 {
-                    Utils.LogWarning("WARNING: ACTIVATE SESSION timed out. {0}/{1}", GoodPublishRequestCount, OutstandingRequestCount);
+                    var error = ServiceResult.Create(StatusCodes.BadRequestTimeout, "ACTIVATE SESSION timed out. {0}/{1}", GoodPublishRequestCount, OutstandingRequestCount);
+                    Utils.LogWarning("WARNING: {0}", error.ToString());
+                    var operation = result as ChannelAsyncOperation<int>;
+                    operation?.Fault(false, error);
                 }
 
                 // reactivate session.
@@ -3690,6 +3706,7 @@
         {
             int keepAliveInterval = m_keepAliveInterval;
 
+            m_lastKeepAliveErrorStatusCode = StatusCodes.Good;
             Interlocked.Exchange(ref m_lastKeepAliveTime, DateTime.UtcNow.Ticks);
 
             m_serverState = ServerState.Unknown;
@@ -3709,7 +3726,7 @@
             {
                 StopKeepAliveTimer();
 
-#if NET6_0_OR_GREATER
+#if PERIODIC_TIMER
                 // start periodic timer loop
                 var keepAliveTimer = new PeriodicTimer(TimeSpan.FromMilliseconds(keepAliveInterval));
                 _ = Task.Run(() => OnKeepAliveAsync(keepAliveTimer, nodesToRead));
@@ -3821,7 +3838,7 @@
             }
         }
 
-#if NET6_0_OR_GREATER
+#if PERIODIC_TIMER
         /// <summary>
         /// Sends a keep alive by reading from the server.
         /// </summary>
@@ -3893,6 +3910,11 @@
 
                 AsyncRequestStarted(result, requestHeader.RequestHandle, DataTypes.ReadRequest);
             }
+            catch (ServiceResultException sre) when (sre.StatusCode == StatusCodes.BadNotConnected)
+            {
+                // recover from error condition when secure channel is still alive
+                OnKeepAliveError(sre.Result);
+            }
             catch (Exception e)
             {
                 Utils.LogError("Could not send keep alive request: {0} {1}", e.GetType().FullName, e.Message);
@@ -3935,10 +3957,10 @@
 
                 return;
             }
-            catch (ServiceResultException sre) when (sre.StatusCode == StatusCodes.BadSessionIdInvalid)
+            catch (ServiceResultException sre)
             {
                 // recover from error condition when secure channel is still alive
-                OnKeepAliveError(ServiceResult.Create(StatusCodes.BadSessionIdInvalid, "Session unavailable for keep alive requests."));
+                OnKeepAliveError(sre.Result);
             }
             catch (Exception e)
             {
@@ -3960,6 +3982,7 @@
                     return;
                 }
 
+                m_lastKeepAliveErrorStatusCode = StatusCodes.Good;
                 Interlocked.Exchange(ref m_lastKeepAliveTime, DateTime.UtcNow.Ticks);
 
                 lock (m_outstandingRequests)
@@ -3977,6 +4000,7 @@
             }
             else
             {
+                m_lastKeepAliveErrorStatusCode = StatusCodes.Good;
                 Interlocked.Exchange(ref m_lastKeepAliveTime, DateTime.UtcNow.Ticks);
             }
 
@@ -4003,22 +4027,28 @@
         /// </summary>
         protected virtual bool OnKeepAliveError(ServiceResult result)
         {
-            long delta = DateTime.UtcNow.Ticks - Interlocked.Read(ref m_lastKeepAliveTime);
+            DateTime now = DateTime.UtcNow;
 
-            Utils.LogInfo(
-                "KEEP ALIVE LATE: {0}s, EndpointUrl={1}, RequestCount={2}/{3}",
-                ((double)delta) / TimeSpan.TicksPerSecond,
-                this.Endpoint?.EndpointUrl,
-                this.GoodPublishRequestCount,
-                this.OutstandingRequestCount);
+            m_lastKeepAliveErrorStatusCode = result.StatusCode;
+            if (result.StatusCode == StatusCodes.BadNoCommunication)
+            {
+                // keep alive read timed out
+                long delta = now.Ticks - Interlocked.Read(ref m_lastKeepAliveTime);
+                Utils.LogInfo(
+                    "KEEP ALIVE LATE: {0}s, EndpointUrl={1}, RequestCount={2}/{3}",
+                    ((double)delta) / TimeSpan.TicksPerSecond,
+                    this.Endpoint?.EndpointUrl,
+                    this.GoodPublishRequestCount,
+                    this.OutstandingRequestCount);
+            }
 
             KeepAliveEventHandler callback = m_KeepAlive;
 
             if (callback != null)
             {
                 try
                 {
-                    KeepAliveEventArgs args = new KeepAliveEventArgs(result, ServerState.Unknown, DateTime.UtcNow);
+                    KeepAliveEventArgs args = new KeepAliveEventArgs(result, ServerState.Unknown, now);
                     callback(this, args);
                     return !args.CancelKeepAlive;
                 }
@@ -5074,43 +5104,40 @@
 
                     case StatusCodes.BadNoSubscription:
                     case StatusCodes.BadSessionClosed:
-                    case StatusCodes.BadSessionIdInvalid:
-                    case StatusCodes.BadSecureChannelIdInvalid:
-                    case StatusCodes.BadSecureChannelClosed:
                     case StatusCodes.BadSecurityChecksFailed:
                     case StatusCodes.BadCertificateInvalid:
                     case StatusCodes.BadServerHalted:
                         return;
 
+                    // may require a reconnect or activate to recover
+                    case StatusCodes.BadSessionIdInvalid:
+                    case StatusCodes.BadSecureChannelIdInvalid:
+                    case StatusCodes.BadSecureChannelClosed:
+                        OnKeepAliveError(error);
+                        return;
+
                     // Servers may return this error when overloaded
                     case StatusCodes.BadTooManyOperations:
                     case StatusCodes.BadTcpServerTooBusy:
                     case StatusCodes.BadServerTooBusy:
                         // throttle the next publish to reduce server load
                         _ = Task.Run(async () => {
                             await Task.Delay(100).ConfigureAwait(false);
-                            BeginPublish(OperationTimeout);
+                            QueueBeginPublish();
                         });
                         return;
 
+                    case StatusCodes.BadTimeout:
+                        break;
+
                     default:
                         Utils.LogError(e, "PUBLISH #{0} - Unhandled error {1} during Publish.", requestHeader.RequestHandle, error.StatusCode);
                         goto case StatusCodes.BadServerTooBusy;
 
                 }
             }
 
-            int requestCount = GoodPublishRequestCount;
-            int minPublishRequestCount = GetMinPublishRequestCount(false);
-
-            if (requestCount < minPublishRequestCount)
-            {
-                BeginPublish(OperationTimeout);
-            }
-            else
-            {
-                Utils.LogInfo("PUBLISH - Did not send another publish request. GoodPublishRequestCount={0}, MinPublishRequestCount={1}", requestCount, minPublishRequestCount);
-            }
+            QueueBeginPublish();
         }
 
         /// <inheritdoc/>
@@ -5201,6 +5228,24 @@
         #endregion
 
         #region Private Methods
+        /// <summary>
+        /// Queues a publish request if there are not enough outstanding requests.
+        /// </summary>
+        private void QueueBeginPublish()
+        {
+            int requestCount = GoodPublishRequestCount;
+            int minPublishRequestCount = GetMinPublishRequestCount(false);
+
+            if (requestCount < minPublishRequestCount)
+            {
+                BeginPublish(OperationTimeout);
+            }
+            else
+            {
+                Utils.LogInfo("PUBLISH - Did not send another publish request. GoodPublishRequestCount={0}, MinPublishRequestCount={1}", requestCount, minPublishRequestCount);
+            }
+        }
+
         /// <summary>
         /// Validates  the identity for an open call.
         /// </summary>
@@ -6315,9 +6360,10 @@
         private long m_publishCounter;
         private int m_tooManyPublishRequests;
         private long m_lastKeepAliveTime;
+        private StatusCode m_lastKeepAliveErrorStatusCode;
         private ServerState m_serverState;
         private int m_keepAliveInterval;
-#if NET6_0_OR_GREATER
+#if PERIODIC_TIMER
         private PeriodicTimer m_keepAliveTimer;
 #else
         private Timer m_keepAliveTimer;

Libraries/Opc.Ua.Client/SessionAsync.cs

@@ -1332,6 +1332,11 @@
         /// <returns>The new session object.</returns>
         public static async Task<Session> RecreateAsync(Session sessionTemplate, ITransportChannel transportChannel, CancellationToken ct = default)
         {
+            if (transportChannel == null)
+            {
+                return await Session.RecreateAsync(sessionTemplate, ct).ConfigureAwait(false);
+            }
+
             ServiceMessageContext messageContext = sessionTemplate.m_configuration.CreateMessageContext();
             messageContext.Factory = sessionTemplate.Factory;
 
@@ -1499,15 +1504,27 @@
                     connection,
                     transportChannel);
 
-                if (!(result is ChannelAsyncOperation<int> operation)) throw new ArgumentNullException(nameof(result));
-
-                try
+                const string timeoutMessage = "ACTIVATE SESSION ASYNC timed out. {0}/{1}";
+                if (result is ChannelAsyncOperation<int> operation)
                 {
-                    _ = await operation.EndAsync(kReconnectTimeout / 2, true, ct).ConfigureAwait(false);
+                    try
+                    {
+                        _ = await operation.EndAsync(kReconnectTimeout / 2, true, ct).ConfigureAwait(false);
+                    }
+                    catch (ServiceResultException sre)
+                    {
+                        if (sre.StatusCode == StatusCodes.BadRequestInterrupted)
+                        {
+                            var error = ServiceResult.Create(StatusCodes.BadRequestTimeout, timeoutMessage,
+                                GoodPublishRequestCount, OutstandingRequestCount);
+                            Utils.LogWarning("WARNING: {0}", error.ToString());
+                            operation.Fault(false, error);
+                        }
+                    }
                 }
-                catch (ServiceResultException)
+                else if (!result.AsyncWaitHandle.WaitOne(kReconnectTimeout / 2))
                 {
-                    Utils.LogWarning("WARNING: ACTIVATE SESSION {0} timed out. {1}/{2}", SessionId, GoodPublishRequestCount, OutstandingRequestCount);
+                    Utils.LogWarning(timeoutMessage, GoodPublishRequestCount, OutstandingRequestCount);
                 }
 
                 // reactivate session.