public bool PosTest2()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest2: Call ctor with string.Empty");
try
{
TimeoutException ex = new TimeoutException(string.Empty);
if (null == ex)
{
TestLibrary.TestFramework.LogError("002.1", "Calling ctor will string.Empty returns null reference");
retVal = false;
}
string message = ex.Message;
// using default message
if (message == null)
{
TestLibrary.TestFramework.LogError("002.2", "Calling ctor will string.Empty returns null message");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("002.0", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
private JsRuntimeException ConvertTimeoutExceptionToJsRuntimeException(
TimeoutException jsTimeoutException)
{
var jsRuntimeException = new JsRuntimeException(Strings.Runtime_ExecutionTimeout,
ENGINE_NAME, ENGINE_VERSION)
{
Category = "TimeoutError",
Source = jsTimeoutException.Source,
HelpLink = jsTimeoutException.HelpLink
};
return(jsRuntimeException);
}
internal static StorageException GenerateTimeoutException(RequestResult res, Exception inner)
{
if (res != null)
{
res.HttpStatusCode = 408; // RequestTimeout
}
TimeoutException timeoutEx = new TimeoutException(SR.TimeoutExceptionMessage, inner);
return new StorageException(res, timeoutEx.Message, timeoutEx)
{
IsRetryable = false
};
}
public void AddSerializedDataDoesNotIncludeNullNestedTypeInExceptionData()
{
var key = Guid.NewGuid().ToString();
var value = Model.Ignoring <Company>(x => x.Owner).Create <Company>();
var sut = new TimeoutException();
sut.AddSerializedData(key, value);
var expected = sut.Data[key] as string;
expected.Should().NotContain(typeof(SerializeFailure).FullName);
}
private JsRuntimeException ConvertTimeoutExceptionToJsRuntimeException(
TimeoutException jsTimeoutException)
{
var jsRuntimeException = new JsRuntimeException(Strings.Runtime_ExecutionTimeout,
EngineName, EngineVersion)
{
Category = "TimeoutError",
Source = jsTimeoutException.Source,
HelpLink = jsTimeoutException.HelpLink
};
return(jsRuntimeException);
}
private static WrapperTimeoutException WrapTimeoutException(TimeoutException originalTimeoutException)
{
string message = CoreStrings.Runtime_ScriptTimeoutExceeded;
string description = message;
var wrapperTimeoutException = new WrapperTimeoutException(message, EngineName, EngineVersion,
originalTimeoutException)
{
Description = description
};
return(wrapperTimeoutException);
}
public void Unwraps_DbUpdateException()
{
var innerException = new TimeoutException();
Assert.True(
DbExecutionStrategy.UnwrapAndHandleException(
new DbUpdateException("", innerException),
ex =>
{
Assert.Same(innerException, ex);
return(true);
}));
}
public async Task LinearRetryRetriesOnNonBatchException()
{
TimeSpan interval = TimeSpan.FromSeconds(5);
const int maxRetries = 10;
LinearRetry linearRetry = new LinearRetry(interval, maxRetries);
TimeoutException timeoutException = new TimeoutException();
RetryDecision retryDecision = await linearRetry.ShouldRetryAsync(timeoutException, new OperationContext());
Assert.Equal(interval, retryDecision.RetryDelay);
Assert.True(retryDecision.ShouldRetry);
}
public void Unwraps_Nested_exceptions()
{
var innerException = new TimeoutException("", new EntityException("", new DbUpdateException("", new UpdateException(""))));
Assert.True(
ExecutionStrategyBase.UnwrapAndHandleException(
new EntityException("", new DbUpdateException("", new UpdateException("", innerException))),
ex =>
{
Assert.Same(innerException, ex);
return(true);
}));
}
internal static StorageException GenerateTimeoutException(RequestResult res, Exception inner)
{
if (res != null)
{
res.HttpStatusCode = 408;
}
TimeoutException ex = new TimeoutException("The client could not finish the operation within specified timeout.", inner);
return(new StorageException(res, ex.Message, ex)
{
IsRetryable = false
});
}
public void HasSerializedDataReturnsWhetherExceptionContainsData()
{
var key = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
var value = Guid.NewGuid().ToString();
var keyNotFound = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
var sut = new TimeoutException();
sut.Data.Add(key, value);
sut.HasSerializedData(key).Should().BeTrue();
sut.HasSerializedData(keyNotFound).Should().BeFalse();
}
/// <summary>
/// Marks a transaction as Failed and provides a <see cref="TimeoutException" /> as the source of failure.
/// This also completes the transaction and releases any waiting threads.
/// </summary>
/// <param name="transaction">The transaction.</param>
/// <param name="message">The message.</param>
public static void TimedOut(this DeviceTransaction transaction, string message = null)
{
var exception = new TimeoutException(message ?? "Timeout");
var type = transaction.GetType();
var onErrorMethod = type.GetMethod("OnError", BindingFlags.Instance | BindingFlags.NonPublic);
onErrorMethod.Invoke(
transaction,
BindingFlags.NonPublic | BindingFlags.Instance,
Type.DefaultBinder,
new object[] { exception },
null);
}
/// <summary>
/// Called when the operation times out.
/// </summary>
private void OnTimeout(object state)
{
try
{
Exception = new TimeoutException();
m_cts?.Cancel();
OperationCompleted();
}
catch (Exception e)
{
Utils.LogTrace(e, "Unexpected error handling timeout for ChannelAsyncResult operation.");
}
}
static StaticData()
{
// Exception created but is not thrown
TestCreatedException = new SystemException("System Test Exception");
// Traditional created and throw exception
try
{
throw new RankException("Rank Test");
}
catch (RankException e)
{
TestThrowException = e;
}
// Exception containing inner exceptions
try
{
try
{
try
{
throw new TypeAccessException("Test Type Exception");
}
catch (TypeAccessException exp1)
{
throw new DivideByZeroException("Divide By Zero Test", exp1);
}
}
catch (DivideByZeroException exp2)
{
throw new ArithmeticException("Inner Exception Test", exp2);
}
}
catch (ArithmeticException exp3)
{
TestInnerException = exp3;
}
// Exception with a defined stack trace
var callClass = new TestNamespace.ClassAlpha();
try
{
callClass.ThrowException();
}
catch (TimeoutException exp)
{
TestCallStackException = exp;
}
}
private IConnection TryConnect(Uri remoteUri, string resolvedAddress, BackoffTimeoutHelper backoffHelper)
{
bool flag = backoffHelper.IsExpired();
int dwFlagsAndAttributes = 0x40000000;
if (this.includeSecurityIdentity)
{
dwFlagsAndAttributes |= 0x110000;
}
PipeHandle handle = UnsafeNativeMethods.CreateFile(resolvedAddress, -1073741824, 0, IntPtr.Zero, 3, dwFlagsAndAttributes, IntPtr.Zero);
int errorCode = Marshal.GetLastWin32Error();
if (handle.IsInvalid)
{
handle.SetHandleAsInvalid();
}
else
{
int mode = 2;
if (UnsafeNativeMethods.SetNamedPipeHandleState(handle, ref mode, IntPtr.Zero, IntPtr.Zero) == 0)
{
errorCode = Marshal.GetLastWin32Error();
handle.Close();
PipeException exception = new PipeException(System.ServiceModel.SR.GetString("PipeModeChangeFailed", new object[] { PipeError.GetErrorString(errorCode) }), errorCode);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.CreateConnectFailedException(remoteUri, exception));
}
return(new PipeConnection(handle, this.bufferSize, false, true));
}
if ((errorCode == 2) || (errorCode == 0xe7))
{
TimeoutException exception3;
if (!flag)
{
return(null);
}
Exception exception2 = new PipeException(System.ServiceModel.SR.GetString("PipeConnectAddressFailed", new object[] { resolvedAddress, PipeError.GetErrorString(errorCode) }), errorCode);
string absoluteUri = remoteUri.AbsoluteUri;
if (errorCode == 0xe7)
{
exception3 = new TimeoutException(System.ServiceModel.SR.GetString("PipeConnectTimedOutServerTooBusy", new object[] { absoluteUri, backoffHelper.OriginalTimeout }), exception2);
}
else
{
exception3 = new TimeoutException(System.ServiceModel.SR.GetString("PipeConnectTimedOut", new object[] { absoluteUri, backoffHelper.OriginalTimeout }), exception2);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception3);
}
PipeException innerException = new PipeException(System.ServiceModel.SR.GetString("PipeConnectAddressFailed", new object[] { resolvedAddress, PipeError.GetErrorString(errorCode) }), errorCode);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(this.CreateConnectFailedException(remoteUri, innerException));
}
internal static Exception ConvertAndTraceException(Exception ex, TimeSpan timeout, string operation)
{
if (ex is ObjectDisposedException objectDisposedException)
{
var communicationObjectAbortedException = new CommunicationObjectAbortedException(ex.Message, ex);
Fx.Exception.AsWarning(communicationObjectAbortedException);
return(communicationObjectAbortedException);
}
if (ex is AggregateException aggregationException)
{
Exception exception = Fx.Exception.AsError <OperationCanceledException>(aggregationException);
if (exception is OperationCanceledException operationCanceledException)
{
TimeoutException timeoutException = GetTimeoutException(exception, timeout, operation);
Fx.Exception.AsWarning(timeoutException);
return(timeoutException);
}
else
{
Exception communicationException = ConvertAggregateExceptionToCommunicationException(aggregationException);
if (communicationException is CommunicationObjectAbortedException)
{
Fx.Exception.AsWarning(communicationException);
return(communicationException);
}
else
{
return(Fx.Exception.AsError(communicationException));
}
}
}
if (ex is WebSocketException webSocketException)
{
switch (webSocketException.WebSocketErrorCode)
{
case WebSocketError.InvalidMessageType:
case WebSocketError.UnsupportedProtocol:
case WebSocketError.UnsupportedVersion:
ex = new ProtocolException(ex.Message, ex);
break;
default:
ex = new CommunicationException(ex.Message, ex);
break;
}
}
return(Fx.Exception.AsError(ex));
}
public static ErrorCategory GetErrorCategoryForException(Exception exception)
{
var errorCategory = ErrorCategory.NotSpecified;
if (exception is ArgumentException)
{
errorCategory = ErrorCategory.InvalidArgument;
}
else if (exception is InvalidOperationException ||
exception is FabricException ||
exception is FabricValidationException)
{
errorCategory = ErrorCategory.InvalidOperation;
}
else if (exception is InvalidDataException ||
exception is InvalidCastException)
{
errorCategory = ErrorCategory.InvalidData;
}
else if (exception is XmlSchemaValidationException ||
exception is XmlException)
{
errorCategory = ErrorCategory.ParserError;
}
else if (exception is TimeoutException)
{
errorCategory = ErrorCategory.OperationTimeout;
exception = new TimeoutException(StringResources.Error_ClusterConnectionTimeout);
}
else if (exception is OperationCanceledException)
{
errorCategory = ErrorCategory.OperationStopped;
}
else if (exception is UnauthorizedAccessException ||
exception is SecurityException)
{
errorCategory = ErrorCategory.SecurityError;
}
else if (exception is NullReferenceException ||
exception is FileNotFoundException ||
exception is DirectoryNotFoundException)
{
errorCategory = ErrorCategory.ResourceUnavailable;
}
else if (exception is FabricTransientException)
{
errorCategory = ErrorCategory.ResourceUnavailable;
}
return(errorCategory);
}
private static string BuildErrorMessage(Exception exception)
{
List <string> result = new List <string>();
//result.Add("Es ist ein Fehler aufgetreten!");
if (exception.GetType() == typeof(InvalidPluginExecutionException))
{
InvalidPluginExecutionException ex = (InvalidPluginExecutionException)exception;
result.Add(ex.Message);
}
else if (exception.GetType() == typeof(FaultException <OrganizationServiceFault>))
{
FaultException <OrganizationServiceFault> ex = (FaultException <OrganizationServiceFault>)exception;
result.Add(ex.Message);
}
else if (exception.GetType() == typeof(TimeoutException))
{
TimeoutException ex = (TimeoutException)exception;
result.Add(string.Format("Message: {0}", ex.Message));
result.Add(string.Format("Stack Trace: {0}", ex.StackTrace));
result.Add(string.Format("Inner Fault: {0}",
null == ex.InnerException.Message ? "Has Inner Fault" : "No Inner Fault"));
}
else
{
Exception ex = exception;
result.Add(string.Format(ex.Message));
// Display the details of the inner exception.
if (ex.InnerException != null)
{
result.Add(string.Format(ex.InnerException.Message));
FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> fe = ex.InnerException
as FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault>;
if (fe != null)
{
result.Add(string.Format("Timestamp: {0}", fe.Detail.Timestamp));
result.Add(string.Format("Code: {0}", fe.Detail.ErrorCode));
result.Add(string.Format("Message: {0}", fe.Detail.Message));
result.Add(string.Format("Trace: {0}", fe.Detail.TraceText));
result.Add(string.Format("Inner Fault: {0}",
null == fe.Detail.InnerFault ? "Has Inner Fault" : "No Inner Fault"));
} //if
} //if
} //if
return(string.Join(Environment.NewLine, result.ToArray()));
}//BuildErrorMessage
public void LogErrorWithWritesLogWithExceptionAndNullContextData()
{
var exception = new TimeoutException();
_logger.LogErrorWithContext(exception, null);
var actual = _logger.Last;
actual.LogLevel.Should().Be(LogLevel.Error);
actual.EventId.Id.Should().Be(0);
actual.Message.Should().BeNull();
actual.Exception.Should().Be(exception);
actual.Exception.Data.Should().BeEmpty();
}
public static ReliableHttpException Create(string message, Exception exception)
{
ReliableHttpException ex;
if (exception.Message.Contains("The request was aborted"))
{
ex = new TimeoutException(message, exception);
}
else
{
ex = new ReliableHttpException(message, exception);
}
return ex;
}
/// <summary>
/// Initializes a new instance of the <see cref="Connection"/> class.
/// </summary>
/// <param name="ipEndPoint">The remote IP endpoint of the connection.</param>
/// <param name="options">The optional options for the connection.</param>
/// <param name="tcpClient">The optional TcpClient instance to use.</param>
public Connection(IPEndPoint ipEndPoint, ConnectionOptions options = null, ITcpClient tcpClient = null)
{
Id = Guid.NewGuid();
IPEndPoint = ipEndPoint;
Options = options ?? new ConnectionOptions();
TcpClient = tcpClient ?? new TcpClientAdapter(new TcpClient());
TcpClient.Client.ReceiveBufferSize = Options.ReadBufferSize;
TcpClient.Client.SendBufferSize = Options.WriteBufferSize;
if (Options.InactivityTimeout > 0)
{
InactivityTimer = new SystemTimer()
{
Enabled = false,
AutoReset = false,
Interval = Options.InactivityTimeout,
};
InactivityTimer.Elapsed += (sender, e) =>
{
var ex = new TimeoutException($"Inactivity timeout of {Options.InactivityTimeout} milliseconds was reached");
Disconnect(ex.Message, ex);
};
}
WatchdogTimer = new SystemTimer()
{
Enabled = false,
AutoReset = true,
Interval = 250,
};
WatchdogTimer.Elapsed += (sender, e) =>
{
if (TcpClient == null || !TcpClient.Connected)
{
Disconnect($"The server connection was closed unexpectedly");
}
};
if (TcpClient.Connected)
{
State = ConnectionState.Connected;
InactivityTimer?.Start();
WatchdogTimer.Start();
Stream = TcpClient.GetStream();
}
}
private static void ReadCallback(object state)
{
Microsoft.ServiceBus.Channels.ServerSessionPreambleConnectionReader serverSessionPreambleConnectionReader = (Microsoft.ServiceBus.Channels.ServerSessionPreambleConnectionReader)state;
bool flag = false;
try
{
try
{
serverSessionPreambleConnectionReader.GetReadResult();
serverSessionPreambleConnectionReader.ContinueReading();
flag = true;
}
catch (CommunicationException communicationException1)
{
CommunicationException communicationException = communicationException1;
if (Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ShouldTraceInformation)
{
Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.TraceHandledException(communicationException, TraceEventType.Information);
}
}
catch (TimeoutException timeoutException1)
{
TimeoutException timeoutException = timeoutException1;
if (Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ShouldTraceInformation)
{
Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.TraceHandledException(timeoutException, TraceEventType.Information);
}
}
catch (Exception exception1)
{
Exception exception = exception1;
if (Fx.IsFatal(exception))
{
throw;
}
if (!ExceptionHandler.HandleTransportExceptionHelper(exception))
{
throw;
}
}
}
finally
{
if (!flag)
{
serverSessionPreambleConnectionReader.Abort();
}
}
}
private static T AsyncToSyncWithTimeout <T>(
Func <AsyncCallback, object, IAsyncResult> begin,
Func <IAsyncResult, T> end,
int millisecondsTimeout)
{
var iar = begin(null, null);
if (!iar.AsyncWaitHandle.WaitOne(millisecondsTimeout))
{
var ex = new TimeoutException();
throw new WebException(ex.Message, ex, WebExceptionStatus.Timeout, null);
}
return(end(iar));
}
void timeoutTimer_Tick(object sender, EventArgs e)
{
string url = String.Empty;
try
{
url = Browser.Url.ToString();
}
catch (Exception)
{
}
exception = new TimeoutException(url);
this.Close();
}
public void AddSerializedDataAppendsValueTypeValuesTest(object value)
{
var key = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
var sut = new TimeoutException();
sut.AddSerializedData(key, value);
var actual = sut.Data[key];
_output.WriteLine("Stored data is: {0}", actual);
actual.Should().Be(value);
}
public async Task CloseAsync(bool aborting, CancellationToken token)
{
if (closed)
{
return;
}
IList <TransportManager> transportManagersCopy;
using (await tableLock.TakeLockAsync())
{
if (closed)
{
return;
}
closed = true;
transportManagersCopy = new List <TransportManager>(transportManagers);
transportManagers.Clear();
TimeoutException timeoutException = null;
foreach (TransportManager transportManager in transportManagersCopy)
{
try
{
if (!aborting && timeoutException == null)
{
await transportManager.CloseAsync(listener, token);
}
else
{
transportManager.Abort(listener);
}
}
catch (TimeoutException ex)
{
timeoutException = ex;
transportManager.Abort(listener);
}
}
if (timeoutException != null)
{
// TODO: Find a way to propagate the timeout value
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.Format(SR.TimeoutOnClose, TimeSpan.Zero), timeoutException));
}
}
}
private void OnAsyncReadComplete(object state)
{
bool flag = false;
try
{
try
{
this.HandleReadComplete();
this.ReadAndDispatch();
flag = true;
}
catch (CommunicationException communicationException1)
{
CommunicationException communicationException = communicationException1;
if (Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ShouldTraceInformation)
{
Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.TraceHandledException(communicationException, TraceEventType.Information);
}
}
catch (TimeoutException timeoutException1)
{
TimeoutException timeoutException = timeoutException1;
if (Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ShouldTraceInformation)
{
Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.TraceHandledException(timeoutException, TraceEventType.Information);
}
}
catch (Exception exception1)
{
Exception exception = exception1;
if (Fx.IsFatal(exception))
{
throw;
}
if (!ExceptionHandler.HandleTransportExceptionHelper(exception))
{
throw;
}
}
}
finally
{
if (!flag)
{
base.Abort();
}
}
}
public void Close(bool aborting, TimeSpan timeout)
{
if (this.closed)
{
return;
}
IList <TransportManager> transportManagersCopy;
lock (this.tableLock)
{
if (this.closed)
{
return;
}
this.closed = true;
transportManagersCopy = new List <TransportManager>(this.transportManagers);
this.transportManagers.Clear();
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
TimeoutException timeoutException = null;
foreach (TransportManager transportManager in transportManagersCopy)
{
try
{
if (!aborting && timeoutException == null)
{
transportManager.Close(listener, timeoutHelper.RemainingTime());
}
else
{
transportManager.Abort(listener);
}
}
catch (TimeoutException ex)
{
timeoutException = ex;
transportManager.Abort(listener);
}
}
if (timeoutException != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new TimeoutException(SR.GetString(SR.TimeoutOnClose, timeout), timeoutException));
}
}
}
internal void CreateTimeoutTimer(HttpWebRequest request)
{
if (Request.ConnectionTimeout > 0)
{
timer = new Timer(s =>
{
timer.Dispose();
if (IsPending && !IsConnected)
{
Exception = new TimeoutException("The connection timed out.");
Abort();
}
}, null, Request.ConnectionTimeout * 1000, Timeout.Infinite);
}
}
private void CheckTimeout(uint current)
{
if (_lastRecvTime == 0)
{
_lastRecvTime = current;
}
if (current - _lastRecvTime <= _recvTimeoutSec * 1000)
{
return;
}
var ex = new TimeoutException("socket recv timeout");
PushError(ex);
}
public void LogCriticalWithWritesLogWithEventIdExceptionAndNullContextData()
{
var eventId = new EventId(Environment.TickCount);
var exception = new TimeoutException();
_logger.LogCriticalWithContext(eventId, exception, null);
var actual = _logger.Last;
actual.LogLevel.Should().Be(LogLevel.Critical);
actual.EventId.Id.Should().Be(eventId.Id);
actual.Message.Should().BeNull();
actual.Exception.Should().Be(exception);
actual.Exception.Data.Should().BeEmpty();
}
public void LogErrorWithWritesLogWithExceptionAndContextData()
{
var exception = new TimeoutException();
var contextData = Guid.NewGuid().ToString();
_logger.LogErrorWithContext(exception, contextData);
var actual = _logger.Last;
actual.LogLevel.Should().Be(LogLevel.Error);
actual.EventId.Id.Should().Be(0);
actual.Message.Should().BeNull();
actual.Exception.Should().Be(exception);
actual.Exception.Data["ContextData"].ToString().Should().Contain(contextData);
}
public static ReliableHttpException Create(Exception exception)
{
if (exception is ReliableHttpException)
{
return (ReliableHttpException) exception;
}
ReliableHttpException ex;
if (exception.Message.Contains("The request was aborted"))
{
ex = new TimeoutException(exception);
}
else
{
ex = new ReliableHttpException(exception);
}
return ex;
}
public bool PosTest1()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest1: Call ctor with null");
try
{
TimeoutException ex = new TimeoutException(null, null);
if (null == ex)
{
TestLibrary.TestFramework.LogError("001.1", "Calling ctor will null returns null reference");
retVal = false;
}
string message = ex.Message;
// using default message
if (message == null)
{
TestLibrary.TestFramework.LogError("001.2", "Calling ctor will null returns null message");
retVal = false;
}
Exception innerException = ex.InnerException;
// using default message
if (innerException != null)
{
TestLibrary.TestFramework.LogError("001.3", "Calling ctor will null returns not null innerException");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
public bool PosTest1()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest1: Call ctor to create a new instance");
try
{
TimeoutException ex = new TimeoutException();
if (ex == null)
{
TestLibrary.TestFramework.LogError("001.1", "Calling ctor returns null reference");
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("001.0", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
public bool PosTest3()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest3: Call ctor with rand message");
try
{
string expected = TestLibrary.Generator.GetString(-55, false, 1, 256);
TimeoutException ex = new TimeoutException(expected);
if (null == ex)
{
TestLibrary.TestFramework.LogError("003.1", "Calling ctor will rand message returns null reference");
retVal = false;
}
string message = ex.Message;
// using default message
if (message != expected)
{
TestLibrary.TestFramework.LogError("003.2", "Calling ctor will rand message returns null message");
TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] message = " + message + ", expected = " + expected);
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("003.0", "Unexpected exception: " + e);
TestLibrary.TestFramework.LogInformation(e.StackTrace);
retVal = false;
}
return retVal;
}
unsafe void WaitForSyncWrite(TimeSpan timeout, bool traceExceptionsAsErrors, ref object holder)
{
if (this.isWriteOutstanding)
{
if (!this.writeOverlapped.WaitForSyncOperation(timeout, ref holder))
{
Abort(SR.GetString(SR.PipeConnectionAbortedWriteTimedOut, this.writeTimeout), TransferOperation.Write);
Exception timeoutException = new TimeoutException(SR.GetString(SR.PipeWriteTimedOut, timeout));
TraceEventType traceEventType = TraceEventType.Information;
if (traceExceptionsAsErrors)
{
traceEventType = TraceEventType.Error;
}
// This intentionally doesn't reset isWriteOutstanding, because technically it still is, and we need to not free the buffer.
throw DiagnosticUtility.ExceptionUtility.ThrowHelper(timeoutException, traceEventType);
}
else
{
this.isWriteOutstanding = false;
}
}
}
static internal TimeoutException TimeoutException(string error)
{
TimeoutException e = new TimeoutException(error);
return e;
}
/// <summary>
/// Creates a <see cref="TimeoutException"/>.
/// </summary>
/// <param name="agent">Agent address</param>
/// <param name="timeout">Timeout</param>
/// <returns></returns>
public static TimeoutException Create(IPAddress agent, int timeout)
{
if (agent == null)
{
throw new ArgumentNullException("agent");
}
var ex = new TimeoutException { Agent = agent, Timeout = timeout };
return ex;
}
protected override TimeoutException CreateNewConnectionTimeoutException(TimeSpan timeout, TimeoutException innerException)
{
return new TimeoutException(SR.GetString(SR.RequestTimedOutEstablishingTransportSession,
timeout, channel.Via.AbsoluteUri), innerException);
}
static void HandleEndWait(object state, TimeoutException e)
{
GetResponseAsyncResult thisPtr = (GetResponseAsyncResult)state;
thisPtr.Complete(false, e);
}
public void Unwraps_Nested_exceptions()
{
var innerException = new TimeoutException("", new EntityException("", new DbUpdateException("", new UpdateException(""))));
Assert.True(
DbExecutionStrategy.UnwrapAndHandleException(
new EntityException("", new DbUpdateException("", new UpdateException("", innerException))),
ex =>
{
Assert.Same(innerException, ex);
return true;
}));
}
static Exception ConvertTransferException(SocketException socketException, TimeSpan timeout, Exception originalException,
TransferOperation transferOperation, bool aborted, string timeoutErrorString, TransferOperation timeoutErrorTransferOperation,
SocketConnection socketConnection, TimeSpan remainingTime)
{
if (socketException.ErrorCode == UnsafeNativeMethods.ERROR_INVALID_HANDLE)
{
return new CommunicationObjectAbortedException(socketException.Message, socketException);
}
if (timeoutErrorString != null)
{
return ConvertTimeoutErrorException(originalException, transferOperation, timeoutErrorString, timeoutErrorTransferOperation);
}
TraceEventType exceptionEventType = socketConnection == null ? TraceEventType.Error : socketConnection.ExceptionEventType;
// 10053 can occur due to our timeout sockopt firing, so map to TimeoutException in that case
if (socketException.ErrorCode == UnsafeNativeMethods.WSAECONNABORTED &&
remainingTime <= TimeSpan.Zero)
{
TimeoutException timeoutException = new TimeoutException(SR.GetString(SR.TcpConnectionTimedOut, timeout), originalException);
if (TD.TcpConnectionTimedOutIsEnabled())
{
if (socketConnection != null)
{
int socketid = (socketConnection != null && socketConnection.socket != null) ? socketConnection.socket.GetHashCode() : -1;
TD.TcpConnectionTimedOut(socketid, socketConnection.RemoteEndpointAddress);
}
}
if (DiagnosticUtility.ShouldTrace(exceptionEventType))
{
TraceUtility.TraceEvent(exceptionEventType, TraceCode.TcpConnectionTimedOut, GetEndpointString(SR.TcpConnectionTimedOut, timeout, null, socketConnection), timeoutException, null);
}
return timeoutException;
}
if (socketException.ErrorCode == UnsafeNativeMethods.WSAENETRESET ||
socketException.ErrorCode == UnsafeNativeMethods.WSAECONNABORTED ||
socketException.ErrorCode == UnsafeNativeMethods.WSAECONNRESET)
{
if (aborted)
{
return new CommunicationObjectAbortedException(SR.GetString(SR.TcpLocalConnectionAborted), originalException);
}
else
{
CommunicationException communicationException = new CommunicationException(SR.GetString(SR.TcpConnectionResetError, timeout), originalException);
if (TD.TcpConnectionResetErrorIsEnabled())
{
if (socketConnection != null)
{
int socketId = (socketConnection.socket != null) ? socketConnection.socket.GetHashCode() : -1;
TD.TcpConnectionResetError(socketId, socketConnection.RemoteEndpointAddress);
}
}
if (DiagnosticUtility.ShouldTrace(exceptionEventType))
{
TraceUtility.TraceEvent(exceptionEventType, TraceCode.TcpConnectionResetError, GetEndpointString(SR.TcpConnectionResetError, timeout, null, socketConnection), communicationException, null);
}
return communicationException;
}
}
else if (socketException.ErrorCode == UnsafeNativeMethods.WSAETIMEDOUT)
{
TimeoutException timeoutException = new TimeoutException(SR.GetString(SR.TcpConnectionTimedOut, timeout), originalException);
if (DiagnosticUtility.ShouldTrace(exceptionEventType))
{
TraceUtility.TraceEvent(exceptionEventType, TraceCode.TcpConnectionTimedOut, GetEndpointString(SR.TcpConnectionTimedOut, timeout, null, socketConnection), timeoutException, null);
}
return timeoutException;
}
else
{
if (aborted)
{
return new CommunicationObjectAbortedException(SR.GetString(SR.TcpTransferError, socketException.ErrorCode, socketException.Message), originalException);
}
else
{
CommunicationException communicationException = new CommunicationException(SR.GetString(SR.TcpTransferError, socketException.ErrorCode, socketException.Message), originalException);
if (DiagnosticUtility.ShouldTrace(exceptionEventType))
{
TraceUtility.TraceEvent(exceptionEventType, TraceCode.TcpTransferError, GetEndpointString(SR.TcpTransferError, TimeSpan.MinValue, socketException, socketConnection), communicationException, null);
}
return communicationException;
}
}
}
internal override void Timeout(InternalTransaction tx)
{
if (DiagnosticTrace.Warning)
{
TransactionTimeoutTraceRecord.Trace(SR.TraceSourceLtm,
tx.TransactionTraceId
);
}
TimeoutException e = new TimeoutException(SR.TraceTransactionTimeout);
Rollback(tx, e);
}
internal override void Timeout(InternalTransaction tx)
{
TransactionsEtwProvider etwLog = TransactionsEtwProvider.Log;
if (etwLog.IsEnabled())
{
etwLog.TransactionTimeout(tx.TransactionTraceId);
}
TimeoutException e = new TimeoutException(SR.TraceTransactionTimeout);
Rollback(tx, e);
}
static void OnWaitComplete(object state, TimeoutException timeoutException)
{
BindReclaimedLockAsyncResult thisPtr = (BindReclaimedLockAsyncResult)state;
Exception completionException = null;
try
{
if (timeoutException != null)
{
thisPtr.context.InstanceHandle.CancelReclaim(new TimeoutException(SRCore.TimedOutWaitingForLockResolution));
}
thisPtr.context.ConcludeBindReclaimedLockHelper();
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
completionException = exception;
}
thisPtr.Complete(false, completionException);
}
static void OnHostTransaction(object state, TimeoutException timeoutException)
{
AcquireContextAsyncResult pThis = (AcquireContextAsyncResult)state;
Exception exception = timeoutException;
bool completeSelf = exception != null;
if (!completeSelf)
{
try
{
if (pThis.DoAfterTransaction())
{
completeSelf = true;
}
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
exception = e;
completeSelf = true;
}
}
if (completeSelf)
{
if (exception != null)
{
pThis.handle.FinishOperation();
}
pThis.Complete(false, exception);
}
}
IConnection TryConnect(Uri remoteUri, string resolvedAddress, BackoffTimeoutHelper backoffHelper)
{
const int access = UnsafeNativeMethods.GENERIC_READ | UnsafeNativeMethods.GENERIC_WRITE;
bool lastAttempt = backoffHelper.IsExpired();
int flags = UnsafeNativeMethods.FILE_FLAG_OVERLAPPED;
// By default Windows named pipe connection is created with impersonation, but we want
// to create it with anonymous and let WCF take care of impersonation/identification.
flags |= UnsafeNativeMethods.SECURITY_QOS_PRESENT | UnsafeNativeMethods.SECURITY_ANONYMOUS;
PipeHandle pipeHandle = UnsafeNativeMethods.CreateFile(resolvedAddress, access, 0, IntPtr.Zero,
UnsafeNativeMethods.OPEN_EXISTING, flags, IntPtr.Zero);
int error = Marshal.GetLastWin32Error();
if (pipeHandle.IsInvalid)
{
pipeHandle.SetHandleAsInvalid();
}
else
{
int mode = UnsafeNativeMethods.PIPE_READMODE_MESSAGE;
if (UnsafeNativeMethods.SetNamedPipeHandleState(pipeHandle, ref mode, IntPtr.Zero, IntPtr.Zero) == 0)
{
error = Marshal.GetLastWin32Error();
pipeHandle.Close();
PipeException innerException = new PipeException(SR.GetString(SR.PipeModeChangeFailed,
PipeError.GetErrorString(error)), error);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
CreateConnectFailedException(remoteUri, innerException));
}
return new PipeConnection(pipeHandle, bufferSize, false, true);
}
if (error == UnsafeNativeMethods.ERROR_FILE_NOT_FOUND || error == UnsafeNativeMethods.ERROR_PIPE_BUSY)
{
if (lastAttempt)
{
Exception innerException = new PipeException(SR.GetString(SR.PipeConnectAddressFailed,
resolvedAddress, PipeError.GetErrorString(error)), error);
TimeoutException timeoutException;
string endpoint = remoteUri.AbsoluteUri;
if (error == UnsafeNativeMethods.ERROR_PIPE_BUSY)
{
timeoutException = new TimeoutException(SR.GetString(SR.PipeConnectTimedOutServerTooBusy,
endpoint, backoffHelper.OriginalTimeout), innerException);
}
else
{
timeoutException = new TimeoutException(SR.GetString(SR.PipeConnectTimedOut,
endpoint, backoffHelper.OriginalTimeout), innerException);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(timeoutException);
}
return null;
}
else
{
PipeException innerException = new PipeException(SR.GetString(SR.PipeConnectAddressFailed,
resolvedAddress, PipeError.GetErrorString(error)), error);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
CreateConnectFailedException(remoteUri, innerException));
}
}
void OnConnectionModeKnownCore(ConnectionModeReader modeReader, bool isCached)
{
lock (ThisLock)
{
if (isDisposed)
return;
this.connectionReaders.Remove(modeReader);
}
bool closeReader = true;
try
{
FramingMode framingMode;
try
{
framingMode = modeReader.GetConnectionMode();
}
catch (CommunicationException exception)
{
TraceEventType eventType = modeReader.Connection.ExceptionEventType;
DiagnosticUtility.TraceHandledException(exception, eventType);
return;
}
catch (TimeoutException exception)
{
if (!isCached)
{
exception = new TimeoutException(SR.GetString(SR.ChannelInitializationTimeout, this.channelInitializationTimeout), exception);
System.ServiceModel.Dispatcher.ErrorBehavior.ThrowAndCatch(exception);
}
if (TD.ChannelInitializationTimeoutIsEnabled())
{
TD.ChannelInitializationTimeout(SR.GetString(SR.ChannelInitializationTimeout, this.channelInitializationTimeout));
}
TraceEventType eventType = modeReader.Connection.ExceptionEventType;
DiagnosticUtility.TraceHandledException(exception, eventType);
return;
}
switch (framingMode)
{
case FramingMode.Duplex:
OnDuplexConnection(modeReader.Connection, modeReader.ConnectionDequeuedCallback,
modeReader.StreamPosition, modeReader.BufferOffset, modeReader.BufferSize,
modeReader.GetRemainingTimeout());
break;
case FramingMode.Singleton:
OnSingletonConnection(modeReader.Connection, modeReader.ConnectionDequeuedCallback,
modeReader.StreamPosition, modeReader.BufferOffset, modeReader.BufferSize,
modeReader.GetRemainingTimeout());
break;
default:
{
Exception inner = new InvalidDataException(SR.GetString(
SR.FramingModeNotSupported, framingMode));
Exception exception = new ProtocolException(inner.Message, inner);
FramingEncodingString.AddFaultString(exception, FramingEncodingString.UnsupportedModeFault);
System.ServiceModel.Dispatcher.ErrorBehavior.ThrowAndCatch(exception);
return;
}
}
closeReader = false;
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
if (!ExceptionHandler.HandleTransportExceptionHelper(e))
{
throw;
}
// containment -- the reader is aborted, no need for additional containment
}
finally
{
if (closeReader)
{
modeReader.Dispose();
}
}
}
static void OnEnteredAsync(object state, TimeoutException exception)
{
EnterAsyncData data = (EnterAsyncData)state;
ThreadNeutralSemaphore thisPtr = data.Semaphore;
Exception exceptionToPropagate = exception;
if (exception != null)
{
if (!thisPtr.RemoveWaiter(data.Waiter))
{
// The timeout ----d with Exit and exit won.
// We've successfully entered.
exceptionToPropagate = null;
}
}
Fx.Assert(!thisPtr.waiters.Contains(data.Waiter), "The waiter should have been removed already.");
if (thisPtr.aborted)
{
exceptionToPropagate = thisPtr.CreateObjectAbortedException();
}
data.Callback(data.State, exceptionToPropagate);
}
static void HandleWaitForStoreEvents(object state, TimeoutException exception)
{
CloseAsyncResult thisPtr = (CloseAsyncResult)state;
if (exception != null)
{
thisPtr.Complete(false, exception);
return;
}
bool completeSelf = false;
Exception completionException = null;
try
{
completeSelf = thisPtr.PerformClose();
}
catch (Exception e)
{
if (Fx.IsFatal(e))
{
throw;
}
completionException = exception;
completeSelf = true;
}
if (completeSelf)
{
thisPtr.Complete(false, completionException);
}
}
private static Exception ConvertTransferException(SocketException socketException, TimeSpan timeout, Exception originalException,
TransferOperation transferOperation, bool aborted, string timeoutErrorString, TransferOperation timeoutErrorTransferOperation,
SocketConnection socketConnection, TimeSpan remainingTime)
{
if ((int)socketException.SocketErrorCode == UnsafeNativeMethods.ERROR_INVALID_HANDLE)
{
return new CommunicationObjectAbortedException(socketException.Message, socketException);
}
if (timeoutErrorString != null)
{
return ConvertTimeoutErrorException(originalException, transferOperation, timeoutErrorString, timeoutErrorTransferOperation);
}
// 10053 can occur due to our timeout sockopt firing, so map to TimeoutException in that case
if ((int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAECONNABORTED &&
remainingTime <= TimeSpan.Zero)
{
TimeoutException timeoutException = new TimeoutException(SR.Format(SR.TcpConnectionTimedOut, timeout), originalException);
return timeoutException;
}
if ((int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAENETRESET ||
(int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAECONNABORTED ||
(int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAECONNRESET)
{
if (aborted)
{
return new CommunicationObjectAbortedException(SR.TcpLocalConnectionAborted, originalException);
}
else
{
CommunicationException communicationException = new CommunicationException(SR.Format(SR.TcpConnectionResetError, timeout), originalException);
return communicationException;
}
}
else if ((int)socketException.SocketErrorCode == UnsafeNativeMethods.WSAETIMEDOUT)
{
TimeoutException timeoutException = new TimeoutException(SR.Format(SR.TcpConnectionTimedOut, timeout), originalException);
return timeoutException;
}
else
{
if (aborted)
{
return new CommunicationObjectAbortedException(SR.Format(SR.TcpTransferError, (int)socketException.SocketErrorCode, socketException.Message), originalException);
}
else
{
CommunicationException communicationException = new CommunicationException(SR.Format(SR.TcpTransferError, (int)socketException.SocketErrorCode, socketException.Message), originalException);
return communicationException;
}
}
}
public void Unwraps_UpdateException()
{
var innerException = new TimeoutException();
Assert.True(
DbExecutionStrategy.UnwrapAndHandleException(
new UpdateException("", innerException),
ex =>
{
Assert.Same(innerException, ex);
return true;
}));
}
static void OnBindReclaimed(object state, TimeoutException timeoutException)
{
ExecuteAsyncResult thisPtr = (ExecuteAsyncResult)state;
bool completeSelf;
Exception completionException = null;
try
{
thisPtr.BindReclaimed(timeoutException != null);
completeSelf = thisPtr.RunLoop();
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
completionException = exception;
completeSelf = true;
}
if (completeSelf)
{
thisPtr.Complete(false, completionException);
}
}
static void OnCommitWait(object state, TimeoutException exception)
{
ExecuteAsyncResult thisPtr = (ExecuteAsyncResult)state;
thisPtr.Complete(false, exception ?? thisPtr.AfterCommitWait());
}
static void HandleWaitForInProgressLoad(object state, TimeoutException timeoutException)
{
LoadOrCreateAsyncResult thisPtr = (LoadOrCreateAsyncResult)state;
if (timeoutException != null)
{
thisPtr.Complete(false, timeoutException);
return;
}
bool completeSelf = false;
Exception completionException = null;
try
{
if (thisPtr.LoadFromCache())
{
completeSelf = true;
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
completionException = exception;
completeSelf = true;
}
if (completeSelf)
{
thisPtr.Complete(false, completionException);
}
}
