public async Task Start(IEnumerable<Task> tasks, CancellationTokenSource cancelSource) { if (tasks == null) throw new ArgumentNullException(nameof(tasks)); if (cancelSource == null) throw new ArgumentNullException(nameof(cancelSource)); while (true) { var task = _task; if (task != null) await Stop().ConfigureAwait(false); using (await _lock.LockAsync().ConfigureAwait(false)) { _cancelSource = cancelSource; if (_task != null) continue; //Another thread sneaked in and started this manager before we got a lock, loop and try again _stopReason = null; WasStopExpected = false; Task[] tasksArray = tasks.ToArray(); _task = Task.Run(async () => { if (tasksArray.Length > 0) { Task<Task> anyTask = tasksArray.Length > 0 ? Task.WhenAny(tasksArray) : null; Task allTasks = tasksArray.Length > 0 ? Task.WhenAll(tasksArray) : null; //Wait for the first task to stop or error Task firstTask = await anyTask.ConfigureAwait(false); //Signal the rest of the tasks to stop if (firstTask.Exception != null) await SignalError(firstTask.Exception).ConfigureAwait(false); else if (StopOnCompletion) //Unless we allow for natural completions await SignalStop().ConfigureAwait(false); //Wait for the other tasks, and signal their errors too just in case try { await allTasks.ConfigureAwait(false); } catch (AggregateException ex) { await SignalError(ex.InnerExceptions.First()).ConfigureAwait(false); } catch (Exception ex) { await SignalError(ex).ConfigureAwait(false); } } if (!StopOnCompletion && !_cancelSource.IsCancellationRequested) { try { await Task.Delay(-1, _cancelSource.Token).ConfigureAwait(false); } //Pause until TaskManager is stopped catch (OperationCanceledException) { } } //Run the cleanup function within our lock if (_stopAction != null) await _stopAction().ConfigureAwait(false); _task = null; _cancelSource = null; }); return; } } }
/// <summary> /// Initializes a new instance of the <see cref="ExceptionContext"/> class using the values provided. /// </summary> /// <param name="exceptionInfo">The exception caught.</param> /// <param name="catchBlock">The catch block where the exception was caught.</param> /// <param name="context">The context in which the exception occurred.</param> public ExceptionContext(ExceptionDispatchInfo exceptionInfo, ExceptionContextCatchBlock catchBlock, CommandHandlerContext context) { if (exceptionInfo == null) { throw new ArgumentNullException("exceptionInfo"); } this.ExceptionInfo = exceptionInfo; if (catchBlock == null) { throw new ArgumentNullException("catchBlock"); } this.CatchBlock = catchBlock; if (context == null) { throw new ArgumentNullException("context"); } this.Context = context; CommandHandlerRequest request = context.Request; if (request == null) { throw Error.ArgumentNull(Resources.TypePropertyMustNotBeNull, typeof(HandlerRequest).Name, "Request", "context"); } this.Request = request; }
public WinRTFileSystemObject(string fullPath, bool asDirectory) { _asDirectory = asDirectory; _fullPath = fullPath; _item = null; _initializationException = null; }
public async Task OnTimeoutExceptionAsync(ExceptionDispatchInfo exceptionInfo, TimeSpan timeoutGracePeriod) { FunctionTimeoutException timeoutException = exceptionInfo.SourceException as FunctionTimeoutException; if (timeoutException?.Task != null) { // We may double the timeoutGracePeriod here by first waiting to see if the iniital // function task that started the exception has completed. Task completedTask = await Task.WhenAny(timeoutException.Task, Task.Delay(timeoutGracePeriod)); // If the function task has completed, simply return. The host has already logged the timeout. if (completedTask == timeoutException.Task) { return; } } LogErrorAndFlush("A function timeout has occurred. Host is shutting down.", exceptionInfo.SourceException); // We can't wait on this as it may cause a deadlock if the timeout was fired // by a Listener that cannot stop until it has completed. Task ignoreTask = _manager.StopAsync(); // Give the manager and all running tasks some time to shut down gracefully. await Task.Delay(timeoutGracePeriod); HostingEnvironment.InitiateShutdown(); }
internal void SignalFailure(ExceptionDispatchInfo error) { if (_storedException == null) { _storedException = error; } SignalComplete(); }
/// <summary> /// Initializes a new instance of the <see cref="CommandHandlerExecutedContext"/> class. /// </summary> /// <param name="handlerContext">Then handler context.</param> /// <param name="exceptionInfo">The <see cref="ExceptionDispatchInfo"/>. Optionnal.</param> public CommandHandlerExecutedContext(CommandHandlerContext handlerContext, ExceptionDispatchInfo exceptionInfo) { if (handlerContext == null) { throw Error.ArgumentNull("handlerContext"); } this.ExceptionInfo = exceptionInfo; this.handlerContext = handlerContext; }
/// <summary> /// Initializes a new instance of the <see cref="EventHandlerOccurredContext"/> class. /// </summary> /// <param name="handlerContext">Then handler context.</param> /// <param name="exceptionInfo">The <see cref="ExceptionDispatchInfo"/>. Optionnal.</param> public EventHandlerOccurredContext(EventHandlerContext handlerContext, ExceptionDispatchInfo exceptionInfo) { if (handlerContext == null) { throw Error.ArgumentNull("handlerContext"); } this.handlerContext = handlerContext; this.ExceptionInfo = exceptionInfo; }
internal HttpRouteExceptionHandler(ExceptionDispatchInfo exceptionInfo, IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler) { Contract.Assert(exceptionInfo != null); Contract.Assert(exceptionLogger != null); Contract.Assert(exceptionHandler != null); _exceptionInfo = exceptionInfo; _exceptionLogger = exceptionLogger; _exceptionHandler = exceptionHandler; }
public void Throw(ExceptionDispatchInfo exceptionInfo) { Debug.Assert(exceptionInfo != null); Thread thread = new Thread(() => { exceptionInfo.Throw(); }); thread.Start(); thread.Join(); }
public void SetException (AggregateException exception) { #if NET_4_5 if (dispatchInfo == null) { // // Used by task awaiter to rethrow an exception with original call stack, it's // needed for first exception only // dispatchInfo = ExceptionDispatchInfo.Capture (exception.InnerException); } #endif this.exception = exception; }
public async Task Start(IEnumerable<Task> tasks, CancellationTokenSource cancelSource) { while (true) { var task = _task; if (task != null) await Stop().ConfigureAwait(false); using (await _lock.LockAsync().ConfigureAwait(false)) { _cancelSource = cancelSource; if (_task != null) continue; //Another thread sneaked in and started this manager before we got a lock, loop and try again _stopReason = null; _wasStopExpected = false; Task[] tasksArray = tasks.ToArray(); Task<Task> anyTask = Task.WhenAny(tasksArray); Task allTasks = Task.WhenAll(tasksArray); _task = Task.Run(async () => { //Wait for the first task to stop or error Task firstTask = await anyTask.ConfigureAwait(false); //Signal the rest of the tasks to stop if (firstTask.Exception != null) await SignalError(firstTask.Exception).ConfigureAwait(false); else await SignalStop().ConfigureAwait(false); //Wait for the other tasks, and signal their errors too just in case try { await allTasks.ConfigureAwait(false); } catch (AggregateException ex) { await SignalError(ex.InnerExceptions.First()).ConfigureAwait(false); } catch (Exception ex) { await SignalError(ex).ConfigureAwait(false); } //Run the cleanup function within our lock if (_stopAction != null) await _stopAction().ConfigureAwait(false); _task = null; _cancelSource = null; }); return; } } }
private void CallCallbackPossiblyUnderLock(SendOrPostCallback callback, Object state) { ThreadContext threadContext = null; try { threadContext = _application.OnThreadEnter(); try { callback(state); } catch (Exception e) { _error = ExceptionDispatchInfo.Capture(e); } } finally { if (threadContext != null) { threadContext.DisassociateFromCurrentThread(); } } }
private static void ThrowEntryPoint() { if (s_EDI == null) { try { ThrowEntryPointInner(); } catch(Exception ex) { Console.WriteLine("Caught exception with message: {0}", ex.Message); s_EDI = ExceptionDispatchInfo.Capture(ex); } } else { Console.WriteLine("s_Exception is not null!"); s_EDI = null; } }
protected internal StreamOperationAsyncResult(IAsyncInfo asyncStreamOperation, AsyncCallback userCompletionCallback, Object userAsyncStateInfo, bool processCompletedOperationInCallback) { if (asyncStreamOperation == null) throw new ArgumentNullException("asyncReadOperation"); _userCompletionCallback = userCompletionCallback; _userAsyncStateInfo = userAsyncStateInfo; _asyncStreamOperation = asyncStreamOperation; _completed = false; _callbackInvoked = false; _bytesCompleted = 0; _errorInfo = null; _processCompletedOperationInCallback = processCompletedOperationInCallback; }
private async Task CheckRetryForExceptionAsync(ExceptionDispatchInfo ex, bool reinitialize) { if (simulator.AsyncRetryHandler == null) { // Simply rethrow the exception. ex.Throw(); } else { // Need to release active keys etc. CancelActiveInteractions(); bool result = await simulator.AsyncRetryHandler(ex); if (!result) throw new SimulatorCanceledException(); // When trying again, we need to re-initialize. if (reinitialize) await InitializeAsync(); } }
private static bool Scenario1() { s_EDI = null; Console.WriteLine("\nScenario1"); Thread t1 = new Thread(new ThreadStart(ThrowEntryPoint)); t1.Start(); t1.Join(); bool fPassed = false; if (s_EDI == null) { Console.WriteLine("s_EDI shouldn't be null!"); goto exit; } // ThrowAndCatch the exception try { s_EDI.Throw(); } catch(Exception ex) { string stackTrace = ex.StackTrace; if (stackTrace.IndexOf("ThrowEntryPoint") == -1) { Console.WriteLine("FAILED - unable to find expected stackTrace"); } else { Console.WriteLine("Caught: {0}", ex.ToString()); Console.WriteLine("Passed"); fPassed = true; } } exit: Console.WriteLine(""); return fPassed; }
/// <summary> /// Initializes a new instance of the <see cref="ExceptionContext"/> class using the values provided. /// </summary> /// <param name="exceptionInfo">The exception caught.</param> /// <param name="catchBlock">The catch block where the exception was caught.</param> /// <param name="request">The request being processed when the exception was caught.</param> public ExceptionContext(ExceptionDispatchInfo exceptionInfo, ExceptionContextCatchBlock catchBlock, CommandHandlerRequest request) { if (exceptionInfo == null) { throw new ArgumentNullException("exceptionInfo"); } this.ExceptionInfo = exceptionInfo; if (catchBlock == null) { throw new ArgumentNullException("catchBlock"); } this.CatchBlock = catchBlock; if (request == null) { throw new ArgumentNullException("request"); } this.Request = request; }
/// <summary> /// Enqueues the function to be executed and executes all resulting continuations until it is completely done /// </summary> public void Run() { Post(async _ => { try { await _task(); } catch (Exception exception) { _caughtException = ExceptionDispatchInfo.Capture(exception); throw; } finally { Post(state => _done = true, null); } }, null); while (!_done) { Tuple<SendOrPostCallback, object> task; if (_items.TryDequeue(out task)) { task.Item1(task.Item2); if (_caughtException == null) continue; _caughtException.Throw(); } else { _workItemsWaiting.WaitOne(); } } }
public async Task CheckRetryForExceptionAsync(ExceptionDispatchInfo ex) => await CheckRetryForExceptionAsync(ex, true);
public void Reset() { // All processors see the _error field write as being no later than the _asyncState field write. _error = null; _asyncState = ASYNC_STATE_NONE; }
public void ReportError() { // Using ExceptionDispatchInfo preserves the Exception's stack trace when rethrowing. ExceptionDispatchInfo error = _error; if (error != null) { _error = null; // prevent long-lived Exception objects on the heap error.Throw(); } }
// Invoked from the callback to signal that the End* method has run to completion. // Returns 'true' if the current thread should call ResumeSteps, 'false' if not. public bool RegisterAsyncCompletion(Exception error) { // Before the call to Exchange below, the _asyncCompletionInfo field will have the value // ASYNC_STATE_NONE or ASYNC_STATE_BEGIN_UNWOUND. If it's the former, then the Begin* method // hasn't yet returned control to IExecutionStep.Execute. From this step's point of view, // this can be treated as a synchronous completion, which will allow us to call ResumeSteps // on the original thread and save the cost of destroying the existing ThreadContext and // creating a new one. If the original value is instead ASYNC_STATE_BEGIN_UNWOUND, then // the Begin* method already returned control to IExecutionStep.Execute and this step was // marked as having an asynchronous completion. The original thread will tear down the // ThreadContext, so the current thread should call back into ResumeSteps to resurrect it. // // If there was an error, we'll use the _error field to store it so that IExecutionStep.Execute // can rethrow it as it's unwinding. // Interlocked performs a volatile write; all processors will see the write to _error as being // no later than the write to _asyncState. _error = (error != null) ? ExceptionDispatchInfo.Capture(error) : null; int originalState = Interlocked.Exchange(ref _asyncState, ASYNC_STATE_CALLBACK_COMPLETED); if (originalState == ASYNC_STATE_NONE) { return false; // IExecutionStep.Execute should call ResumeSteps } Debug.Assert(originalState == ASYNC_STATE_BEGIN_UNWOUND, "Unexpected state."); _error = null; // to prevent long-lived exception object; write doesn't need to be volatile since nobody reads this field anyway in this case return true; // this thread should call ResumeSteps }
// // This is to reset auth state on remote side. // If this write succeeds we will allow auth retrying. // private void StartSendAuthResetSignal(ProtocolToken message, AsyncProtocolRequest asyncRequest, ExceptionDispatchInfo exception) { if (message == null || message.Size == 0) { // // We don't have an alert to send so cannot retry and fail prematurely. // exception.Throw(); } if (asyncRequest == null) { InnerStream.Write(message.Payload, 0, message.Size); } else { asyncRequest.AsyncState = exception; IAsyncResult ar = InnerStreamAPM.BeginWrite(message.Payload, 0, message.Size, s_writeCallback, asyncRequest); if (!ar.CompletedSynchronously) { return; } InnerStreamAPM.EndWrite(ar); } exception.Throw(); }
internal void ValidateCreateContext(bool isServer, string targetHost, SslProtocols enabledSslProtocols, X509Certificate serverCertificate, X509CertificateCollection clientCertificates, bool remoteCertRequired, bool checkCertRevocationStatus, bool checkCertName) { // // We don't support SSL alerts right now, hence any exception is fatal and cannot be retried. // if (_exception != null) { _exception.Throw(); } if (Context != null && Context.IsValidContext) { throw new InvalidOperationException(SR.net_auth_reauth); } if (Context != null && IsServer != isServer) { throw new InvalidOperationException(SR.net_auth_client_server); } if (targetHost == null) { throw new ArgumentNullException(nameof(targetHost)); } if (isServer && serverCertificate == null) { throw new ArgumentNullException(nameof(serverCertificate)); } if ((int)enabledSslProtocols == 0) { throw new ArgumentException(SR.Format(SR.net_invalid_enum, "SslProtocolType"), "sslProtocolType"); } if (clientCertificates == null) { clientCertificates = new X509CertificateCollection(); } if (targetHost.Length == 0) { targetHost = "?" + Interlocked.Increment(ref s_uniqueNameInteger).ToString(NumberFormatInfo.InvariantInfo); } _exception = null; try { _context = new SecureChannel(targetHost, isServer, enabledSslProtocols, serverCertificate, clientCertificates, remoteCertRequired, checkCertName, checkCertRevocationStatus, _encryptionPolicy, _certSelectionDelegate); } catch (Win32Exception e) { throw new AuthenticationException(SR.net_auth_SSPI, e); } }
// // This is to not depend on GC&SafeHandle class if the context is not needed anymore. // internal void Close() { _exception = ExceptionDispatchInfo.Capture(new ObjectDisposedException("SslStream")); if (Context != null) { Context.Close(); } }
private static void SetCustomLoaderFailure(string appId, ExceptionDispatchInfo error) { _customLoaderStartupError = new KeyValuePair<string, ExceptionDispatchInfo>(appId, error); }
internal LazyException(Exception exception, LazyThreadSafetyMode mode) { m_exceptionInfo = System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(exception); m_mode = mode; }
/// <summary>Sets the cancellation exception.</summary> /// <param name="exceptionObject">The cancellation exception.</param> /// <remarks> /// Must be called under lock. /// </remarks> private void SetCancellationException(object exceptionObject) { Contract.Requires(exceptionObject != null, "Expected exceptionObject to be non-null."); Debug.Assert(m_cancellationException == null, "Expected SetCancellationException to be called only once."); // Breaking this assumption will overwrite a previously OCE, // and implies something may be wrong elsewhere, since there should only ever be one. Debug.Assert(m_faultExceptions == null, "Expected SetCancellationException to be called before any faults were added."); // Breaking this assumption shouldn't hurt anything here, but it implies something may be wrong elsewhere. // If this changes, make sure to only conditionally mark as handled below. // Store the cancellation exception var oce = exceptionObject as OperationCanceledException; if (oce != null) { m_cancellationException = ExceptionDispatchInfo.Capture(oce); } else { var edi = exceptionObject as ExceptionDispatchInfo; Debug.Assert(edi != null && edi.SourceException is OperationCanceledException, "Expected an OCE or an EDI that contained an OCE"); m_cancellationException = edi; } // This is just cancellation, and there are no faults, so mark the holder as handled. MarkAsHandled(false); }
private static HttpRouteExceptionHandler CreateProductUnderTest(ExceptionDispatchInfo exceptionInfo) { return new HttpRouteExceptionHandler(exceptionInfo); }
private static HttpRouteExceptionHandler CreateProductUnderTest(ExceptionDispatchInfo exceptionInfo, IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler) { return new HttpRouteExceptionHandler(exceptionInfo, exceptionLogger, exceptionHandler); }
private IntPtr AllocException(Exception ex) { _lastException = ExceptionDispatchInfo.Capture(ex); string exString = ex.ToString(); IntPtr nativeException = AllocException(exString, exString.Length); if (_nativeExceptions == null) { _nativeExceptions = new List<IntPtr>(); } _nativeExceptions.Add(nativeException); return nativeException; }