/// <summary> /// Raised when a keep alive response is returned from the server. /// </summary> static void Session_KeepAlive(Session session, KeepAliveEventArgs e) { Console.WriteLine("===>>> Session KeepAlive: {0} ServerTime: {1:HH:MM:ss}", e.CurrentState, e.CurrentTime.ToLocalTime()); }
/// <summary> /// Updates the status control when a keep alive event occurs. /// </summary> void StandardClient_KeepAlive(Session sender, KeepAliveEventArgs e) { if (InvokeRequired) { BeginInvoke(new KeepAliveEventHandler(StandardClient_KeepAlive), sender, e); return; } else if (!IsHandleCreated) { return; } if (sender != null && sender.Endpoint != null) { ServerUrlLB.Text = Utils.Format( "{0} ({1}) {2}", sender.Endpoint.EndpointUrl, sender.Endpoint.SecurityMode, (sender.EndpointConfiguration.UseBinaryEncoding)?"UABinary":"XML"); } else { ServerUrlLB.Text = "None"; } if (e != null && m_session != null) { if (ServiceResult.IsGood(e.Status)) { ServerStatusLB.Text = Utils.Format( "Server Status: {0} {1:yyyy-MM-dd HH:mm:ss} {2}/{3}", e.CurrentState, e.CurrentTime.ToLocalTime(), m_session.OutstandingRequestCount, m_session.DefunctRequestCount); ServerStatusLB.ForeColor = Color.Empty; ServerStatusLB.Font = new Font(ServerStatusLB.Font, FontStyle.Regular); } else { ServerStatusLB.Text = String.Format( "{0} {1}/{2}", e.Status, m_session.OutstandingRequestCount, m_session.DefunctRequestCount); ServerStatusLB.ForeColor = Color.Red; ServerStatusLB.Font = new Font(ServerStatusLB.Font, FontStyle.Bold); if (m_reconnectPeriod <= 0) { return; } if (m_reconnectHandler == null && m_reconnectPeriod > 0) { m_reconnectHandler = new SessionReconnectHandler(); m_reconnectHandler.BeginReconnect(m_session, m_reconnectPeriod * 1000, StandardClient_Server_ReconnectComplete); } } } }
/// <summary> /// Updates the status control when a keep alive event occurs. /// </summary> async void StandardClient_KeepAlive(Session sender, KeepAliveEventArgs e) { if (!Dispatcher.HasThreadAccess) { await Dispatcher.RunAsync( CoreDispatcherPriority.Normal, () => { StandardClient_KeepAlive( sender, e); }); return; } if (sender != null && sender.Endpoint != null) { ServerUrlTB.Text = Utils.Format( "{0} ({1}) {2}", sender.Endpoint.EndpointUrl, sender.Endpoint.SecurityMode, (sender.EndpointConfiguration.UseBinaryEncoding) ? "UABinary" : "XML"); } else { ServerUrlTB.Text = "None"; } if (e != null && m_session != null) { SessionsCTRL.UpdateSessionNode(m_session); if (ServiceResult.IsGood(e.Status)) { ServerStatusTB.Text = Utils.Format( "Server Status: {0} {1:yyyy-MM-dd HH:mm:ss} {2}/{3}", e.CurrentState, e.CurrentTime.ToLocalTime(), m_session.OutstandingRequestCount, m_session.DefunctRequestCount); ServerStatusTB.Foreground = new SolidColorBrush(Colors.Black); ServerStatusTB.FontWeight = FontWeights.Normal; } else { ServerStatusTB.Text = String.Format( "{0} {1}/{2}", e.Status, m_session.OutstandingRequestCount, m_session.DefunctRequestCount); ServerStatusTB.Foreground = new SolidColorBrush(Colors.Red); ServerStatusTB.FontWeight = FontWeights.Bold; } } }
/// <summary> /// Reports keep alive responses from the server. /// </summary> void Session_Reconnect(Session session, KeepAliveEventArgs e) { m_keepAliveCount++; if (ServiceResult.IsBad(e.Status)) { if (m_keepAliveCount > 2) { m_error = e.Status; m_errorEvent.Set(); } } }
/// <summary> /// Reports keep alive responses from the server. /// </summary> void Session_KeepAlive(Session session, KeepAliveEventArgs e) { if (ServiceResult.IsBad(e.Status)) { m_error = e.Status; m_errorEvent.Set(); return; } m_keepAliveCount++; }
/// <summary> /// Handles a keep alive notification for a session by updating the status bar. /// </summary> private void Session_KeepAlive(Session session, KeepAliveEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new KeepAliveEventHandler(Session_KeepAlive), session, e); return; } try { // check for events from discarded sessions. if (!Object.ReferenceEquals(session, m_session)) { return; } if (ServiceResult.IsBad(e.Status)) { if (m_reconnectHandler == null) { LastKeepAliveTimeLB.Text = e.Status.ToString(); LastKeepAliveTimeLB.ForeColor = Color.Red; ConnectedLB.Text = "Reconnecting"; m_reconnectHandler = new SessionReconnectHandler(); m_reconnectHandler.BeginReconnect(m_session, 10000, Server_ReconnectComplete); } return; } LastKeepAliveTimeLB.Text = Utils.Format("{0:HH:mm:ss}", e.CurrentTime.ToLocalTime()); LastKeepAliveTimeLB.ForeColor = Color.Empty; } catch (Exception exception) { MessageBox.Show(exception.Message, this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error); } }
/// <summary> /// Called when a error occurs during a keep alive. /// </summary> protected virtual bool OnKeepAliveError(ServiceResult result) { long delta = 0; lock (m_eventLock) { delta = DateTime.UtcNow.Ticks - m_lastKeepAliveTime.Ticks; } Utils.Trace( "KEEP ALIVE LATE: {0}s, EndpointUrl={1}, RequestCount={3}/{2}", ((double)delta)/TimeSpan.TicksPerSecond, this.Endpoint.EndpointUrl, this.OutstandingRequestCount, this.GoodPublishRequestCount); KeepAliveEventHandler callback = null; lock (m_eventLock) { callback = m_KeepAlive; } if (callback != null) { try { KeepAliveEventArgs args = new KeepAliveEventArgs(result, ServerState.Unknown, DateTime.UtcNow); callback(this, args); return !args.CancelKeepAlive; } catch (Exception e) { Utils.Trace(e, "Session: Unexpected error invoking KeepAliveCallback."); } } return true; }
/// <summary> /// The session the keep alive handler. /// </summary> /// <param name="session">The session.</param> /// <param name="e">The <see cref="Opc.Ua.Client.KeepAliveEventArgs"/> instance containing the event data.</param> private void Session_KeepAlive(Session session, KeepAliveEventArgs e) { int missedKeepAlives = 0; lock (m_lock) { // check if the session is closed. if (!m_running || !Object.ReferenceEquals(m_session, session)) { return; } // check if everything is ok. if (ServiceResult.IsGood(e.Status)) { m_missedKeepAlives = 0; m_lastKeepAliveTime = DateTime.UtcNow; return; } // increment miss count. missedKeepAlives = ++m_missedKeepAlives; } // attempt to reconnect after two misses. if (missedKeepAlives == 2) { ThreadPool.QueueUserWorkItem(OnReconnectSession, session); Utils.Trace("Calling OnReconnectSession NOW."); } }
/// <summary> /// Raised when a keep alive response is returned from the server. /// </summary> private void Session_KeepAlive(Session session, KeepAliveEventArgs e) { if (ServiceResult.IsBad(e.Status)) { Report("KEEP ALIVE LATE: {0}", e.Status); } }
/// <summary> /// Handles a keep alive event from a session. /// </summary> private void Session_KeepAlive(Session session, KeepAliveEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new KeepAliveEventHandler(Session_KeepAlive), session, e); return; } try { // check for events from discarded sessions. if (!Object.ReferenceEquals(session, m_session)) { return; } // start reconnect sequence on communication error. if (ServiceResult.IsBad(e.Status)) { if (m_reconnectPeriod <= 0) { UpdateStatus(true, e.CurrentTime, "Communication Error ({0})", e.Status); return; } UpdateStatus(true, e.CurrentTime, "Reconnecting in {0}s", m_reconnectPeriod); if (m_reconnectHandler == null) { if (m_ReconnectStarting != null) { m_ReconnectStarting(this, e); } m_reconnectHandler = new SessionReconnectHandler(); m_reconnectHandler.BeginReconnect(m_session, m_reconnectPeriod * 1000, Server_ReconnectComplete); } return; } // update status. UpdateStatus(false, e.CurrentTime, "Connected [{0}]", session.Endpoint.EndpointUrl); // raise any additional notifications. if (m_KeepAliveComplete != null) { m_KeepAliveComplete(this, e); } } catch (Exception exception) { ClientUtils.HandleException(this.Text, exception); } }
/// <summary> /// Updates the server listview item when a keep alive event occurs from the server. /// </summary> void StandardClient_KeepAlive(Session sender, KeepAliveEventArgs e) { if (InvokeRequired) { BeginInvoke(new KeepAliveEventHandler(StandardClient_KeepAlive), sender, e); return; } else if (!IsHandleCreated) { return; } if (sender != null) { ListViewItem[] lvis = ServerListView.Items.Find(sender.SessionId.ToString(), false); if (lvis.Length == 1) { lvis[0].SubItems[(int)ServerColumnHeader.URL].Text = sender.Endpoint.EndpointUrl.ToString(); lvis[0].SubItems[(int)ServerColumnHeader.SecurityMode].Text = sender.Endpoint.SecurityMode.ToString(); lvis[0].SubItems[(int)ServerColumnHeader.SecurityPolicy].Text = SecurityPolicies.GetDisplayName(sender.Endpoint.SecurityPolicyUri); lvis[0].SubItems[(int)ServerColumnHeader.Encoding].Text = (sender.InnerChannel.UseBinaryEncoding) ? "Binary" : "XML"; if (e != null) { if (ServiceResult.IsGood(e.Status)) { lvis[0].SubItems[(int)ServerColumnHeader.KeepAlive].Text = Utils.Format("{0} {1:yyyy-MM-dd HH:mm:ss}", e.CurrentState, e.CurrentTime.ToLocalTime()); } else { lvis[0].SubItems[(int)ServerColumnHeader.KeepAlive].Text = e.Status.SymbolicId; } } } } else { Utils.Trace("{0} sender is null", MethodBase.GetCurrentMethod()); } }
/// <summary> /// Handles a keep alive event from a session. /// </summary> private void Session_KeepAlive(Session session, KeepAliveEventArgs e) { try { // check for events from discarded sessions. if (!Object.ReferenceEquals(session, m_session)) { return; } // start reconnect sequence on communication error. if (ServiceResult.IsBad(e.Status)) { lock (m_lock) { if (m_reconnectPeriod <= 0) { return; } BeginReconnect(); } } } catch (Exception exception) { Utils.Trace(exception, "Unexpected error handling keep alive."); } }