public static void EndOfStreamException_Ctor_String_Exception()
{
Exception ex = new Exception(innerExceptionMessage);
EndOfStreamException i = new EndOfStreamException(exceptionMessage, ex);
Assert.Equal(exceptionMessage, i.Message);
Assert.Equal(i.InnerException.Message, innerExceptionMessage);
Assert.Equal(i.InnerException.HResult, ex.HResult);
Assert.Equal(COR_E_ENDOFSTREAM, (uint)i.HResult);
}
public void HeartbeatReadLoop()
{
while (!m_closed)
{
if (!m_heartbeatRead.WaitOne(Heartbeat * 1000, false))
m_missedHeartbeats++;
else
m_missedHeartbeats = 0;
// Has to miss two full heartbeats to force socket close
if (m_missedHeartbeats > 1)
{
String description = "Heartbeat missing with heartbeat == " +
m_heartbeat + " seconds";
EndOfStreamException eose = new EndOfStreamException(description);
m_shutdownReport.Add(new ShutdownReportEntry(description, eose));
HandleMainLoopException(new ShutdownEventArgs(
ShutdownInitiator.Library,
0,
"End of stream",
eose));
break;
}
}
TerminateMainloop();
FinishClose();
}
public void HeartbeatReadTimerCallback(object state)
{
bool shouldTerminate = false;
try
{
if (!m_closed)
{
if (!m_heartbeatRead.WaitOne(0))
{
m_missedHeartbeats++;
}
else
{
m_missedHeartbeats = 0;
}
// We check against 8 = 2 * 4 because we need to wait for at
// least two complete heartbeat setting intervals before
// complaining, and we've set the socket timeout to a quarter
// of the heartbeat setting in setHeartbeat above.
if (m_missedHeartbeats > 2 * 4)
{
String description = String.Format("Heartbeat missing with heartbeat == {0} seconds", m_heartbeat);
var eose = new EndOfStreamException(description);
ESLog.Error(description, eose);
m_shutdownReport.Add(new ShutdownReportEntry(description, eose));
HandleMainLoopException(
new ShutdownEventArgs(ShutdownInitiator.Library, 0, "End of stream", eose));
shouldTerminate = true;
}
}
if (shouldTerminate)
{
TerminateMainloop();
FinishClose();
}
else if(_heartbeatReadTimer != null)
{
_heartbeatReadTimer.Change(Heartbeat * 1000, Timeout.Infinite);
}
}
catch (ObjectDisposedException)
{
// timer is already disposed,
// e.g. due to shutdown
}
catch (NullReferenceException)
{
// timer has already been disposed from a different thread after null check
// this event should be rare
}
}
///<summary>Closes this Subscription, cancelling the consumer
///record in the server.</summary>
public void Close()
{
try
{
bool shouldCancelConsumer = false;
if (m_consumer != null)
{
shouldCancelConsumer = m_consumer.IsRunning;
m_consumer = null;
}
if (shouldCancelConsumer)
{
if (Model.IsOpen)
{
Model.BasicCancel(ConsumerTag);
}
ConsumerTag = null;
}
m_queueCts.Cancel(true);
if(m_queue != null)
{
m_queue.Dispose();
m_queue = null;
}
#if NETFX_CORE || NET4
var exn = new EndOfStreamException("Subscription closed");
foreach (var tsc in m_waiting)
{
tsc.TrySetException(exn);
}
#endif
}
catch (OperationInterruptedException)
{
// We don't mind, here.
}
}
private static EmberException CreateEmberException(EndOfStreamException ex) =>
new EmberException("Unexpected end of stream.", ex);
public void HeartbeatReadTimerCallback(object state)
{
bool shouldTerminate = false;
if (!m_closed)
{
if (!m_heartbeatRead.WaitOne(0))
{
m_missedHeartbeats++;
}
else
{
m_missedHeartbeats = 0;
}
// We check against 8 = 2 * 4 because we need to wait for at
// least two complete heartbeat setting intervals before
// complaining, and we've set the socket timeout to a quarter
// of the heartbeat setting in setHeartbeat above.
if (m_missedHeartbeats > 2 * 4)
{
String description = String.Format("Heartbeat missing with heartbeat == {0} seconds", m_heartbeat);
var eose = new EndOfStreamException(description);
m_shutdownReport.Add(new ShutdownReportEntry(description, eose));
HandleMainLoopException(
new ShutdownEventArgs(ShutdownInitiator.Library, 0, "End of stream", eose));
shouldTerminate = true;
}
}
if (shouldTerminate)
{
TerminateMainloop();
FinishClose();
}
else
{
_heartbeatReadTimer.Change(Heartbeat * 1000, Timeout.Infinite);
}
}
public static void EndOfStreamException_Ctor_String()
{
EndOfStreamException i = new EndOfStreamException(exceptionMessage);
Assert.Equal(exceptionMessage, i.Message);
Assert.Equal(COR_E_ENDOFSTREAM, (uint)i.HResult);
}
public static void EndOfStreamException_Ctor_Empty()
{
EndOfStreamException i = new EndOfStreamException();
Assert.Equal(COR_E_ENDOFSTREAM, (uint)i.HResult);
}
/// <summary>
/// Objects of this class spend most of their execution time in this method. It simply waits asynchronously (control
/// is returned to the constructor and then returned here on an interrupt) for data. When data is read it is packaged
/// and sent to the event dispatcher.
/// </summary>
/// <returns></returns>
/// <exception cref="ReceiverExceptions">Thrown when the EOF is reached on the read stream (contains an
/// EndOfStreamException</exception>
public async Task run()
{
while (goState > 0)
{
var ret = string.Empty;
var buffer = new char[1]; // Not the most efficient...
while (!ret.Contains("\n") && (!ret.Contains("\r")))
{
var charsRead = await textReader.ReadAsync(buffer, 0, 1);
if (charsRead == 0)
{
EndOfStreamException eose = new EndOfStreamException();
ReceiverExceptions re = new ReceiverExceptions(this,"End of stream reached on serial port.",true,eose);
dispatcher.enqueueEvent(new RealTimeEvents.ExcepReceiver(re, re.fatal,
this, this.portName, this.VEMCO_SerialNumber, this.VEMCO_Model, this.encoder.encoderConfig));
throw re;
}
ret += buffer[0];
}
if (ret.Length > 1)
{
dispatcher.enqueueEvent(new RealTimeEvents.UnparsedMessage(ret,
this, this.portName, this.VEMCO_SerialNumber, this.VEMCO_Model, this.encoder.encoderConfig));
}
}
goState = -1;
}
public void FinishSend(Exception exception)
{
if (exception == null && !_clientClosedConnection)
{
var tcs = _tcsSend;
_tcsSend = null;
if (tcs != null)
{
tcs.SetResult(true);
}
else if (_isWebSocket)
{
_isWebSocket = false;
_next.UpgradedToWebSocket(true);
}
}
else
{
var tcs = _tcsSend;
_tcsSend = null;
_isKeepAlive = false;
if (tcs != null)
{
if (exception == null) exception = new EndOfStreamException("Client closed connection");
tcs.SetException(exception);
}
else if (_isWebSocket)
{
_isWebSocket = false;
_next.UpgradedToWebSocket(false);
}
}
if (_lastPacket)
{
_lastPacket = false;
if (_isKeepAlive && !_clientClosedConnection)
{
ResetForNextRequest();
StartNextReceive();
}
else
{
CloseConnection();
}
}
}
protected void HandleIOException(Exception e)
{
// socket error when in negotiation, throw BrokerUnreachableException
// immediately
if (m_inConnectionNegotiation)
{
var cfe = new ConnectFailureException("I/O error before connection negotiation was completed", e);
throw new BrokerUnreachableException(cfe);
}
if (++m_missedHeartbeats >= SOCKET_TIMEOUTS_TO_CONSIDER_PEER_UNRESPONSIVE)
{
var description =
String.Format("Peer missed 2 heartbeats with heartbeat timeout set to {0} seconds",
m_heartbeat);
var eose = new EndOfStreamException(description);
m_shutdownReport.Add(new ShutdownReportEntry(description, eose));
HandleMainLoopException(new ShutdownEventArgs(ShutdownInitiator.Library,
0,
"End of stream",
eose));
TerminateMainloop();
FinishClose();
}
}
