Beispiel #1
0
        internal bool RecordFailure(Exception e, InternalCommand command)
        {
            bool stopping = false;

            lock (this.StopReasonLock)
            {
                if (this.firstTerminatingError == null)
                {
                    RuntimeException.LockStackTrace(e);
                    this.firstTerminatingError = e;
                }
                else if ((!(this.firstTerminatingError is PipelineStoppedException) && (command != null)) && (command.Context != null))
                {
                    Exception innerException = e;
                    while (((innerException is TargetInvocationException) || (innerException is CmdletInvocationException)) && (innerException.InnerException != null))
                    {
                        innerException = innerException.InnerException;
                    }
                    if (!(innerException is PipelineStoppedException))
                    {
                        InvalidOperationException exception = new InvalidOperationException(StringUtil.Format(PipelineStrings.SecondFailure, new object[] { this.firstTerminatingError.GetType().Name, this.firstTerminatingError.StackTrace, innerException.GetType().Name, innerException.StackTrace }), innerException);
                        MshLog.LogCommandHealthEvent(command.Context, exception, Severity.Warning);
                    }
                }
                stopping      = this.stopping;
                this.stopping = true;
            }
            return(!stopping);
        }
Beispiel #2
0
        // Keep in sync:
        // S.M.A.CommandProcessorBase.CheckForSevereException
        // S.M.A.Internal.ConsoleHost.CheckForSevereException
        // S.M.A.Commands.CommandsCommon.CheckForSevereException
        // S.M.A.Commands.UtilityCommon.CheckForSevereException
        /// <summary>
        /// Checks whether the exception is a severe exception which should
        /// cause immediate process failure.
        /// </summary>
        /// <param name="cmdlet"></param>
        /// <param name="e"></param>
        /// <remarks>
        /// CB says 02/23/2005: I personally would err on the side
        /// of treating OOM like an application exception, rather than
        /// a critical system failure.I think this will be easier to justify
        /// in Orcas, if we tease apart the two cases of OOM better.
        /// But even in Whidbey, how likely is it that we couldnt JIT
        /// some backout code?  At that point, the process or possibly
        /// the machine is likely to stop executing soon no matter
        /// what you do in this routine.  So I would just consider
        /// AccessViolationException.  (I understand why you have SO here,
        /// at least temporarily).
        /// </remarks>
        internal static void CheckForSevereException(Cmdlet cmdlet, Exception e)
        {
            if (e is AccessViolationException || e is StackOverflowException)
            {
                try
                {
                    if (!alreadyFailing)
                    {
                        alreadyFailing = true;

                        // Log a command health event for this critical error.
                        MshLog.LogCommandHealthEvent(
                            cmdlet.Context,
                            e,
                            Severity.Critical);
                    }
                }
                finally
                {
                    if (!designForTestability_SkipFailFast)
                    {
                        WindowsErrorReporting.FailFast(e);
                    }
                }
            }
        }
Beispiel #3
0
        // Keep in sync:
        // S.M.A.CommandProcessorBase.CheckForSevereException
        // S.M.A.Internal.ConsoleHost.CheckForSevereException
        // S.M.A.Commands.CommandsCommon.CheckForSevereException
        // S.M.A.Commands.UtilityCommon.CheckForSevereException
        /// <summary>
        /// Checks whether the exception is a severe exception which should
        /// cause immediate process failure.
        /// </summary>
        /// <param name="cmdlet">can be null</param>
        /// <param name="e"></param>
        /// <remarks>
        /// CB says 02/23/2005: I personally would err on the side
        /// of treating OOM like an application exception, rather than
        /// a critical system failure.I think this will be easier to justify
        /// in Orcas, if we tease apart the two cases of OOM better.
        /// But even in Whidbey, how likely is it that we couldnt JIT
        /// some backout code?  At that point, the process or possibly
        /// the machine is likely to stop executing soon no matter
        /// what you do in this routine.  So I would just consider
        /// AccessViolationException.  (I understand why you have SO here,
        /// at least temporarily).
        /// </remarks>
        internal static void CheckForSevereException(PSCmdlet cmdlet, Exception e)
        {
            if (e is AccessViolationException || e is StackOverflowException)
            {
                try
                {
                    if (!alreadyFailing)
                    {
                        alreadyFailing = true;

                        // Get the ExecutionContext from the thread.
                        ExecutionContext context =
                            (null != cmdlet)
                                ? cmdlet.Context
                                : LocalPipeline.GetExecutionContextFromTLS();

                        // Log a command health event for this critical error.
                        MshLog.LogCommandHealthEvent(context, e, Severity.Critical);
                    }
                }
                finally
                {
                    if (!designForTestability_SkipFailFast)
                    {
                        WindowsErrorReporting.FailFast(e);
                    }
                }
            }
        }
Beispiel #4
0
 private void DisposeCommands()
 {
     this.stopping = true;
     this.FlushLog();
     if (this._commands != null)
     {
         for (int i = 0; i < this._commands.Count; i++)
         {
             CommandProcessorBase base2 = this._commands[i];
             if (base2 != null)
             {
                 try
                 {
                     base2.CommandRuntime.RemoveVariableListsInPipe();
                     base2.Dispose();
                 }
                 catch (Exception exception)
                 {
                     CommandProcessorBase.CheckForSevereException(exception);
                     InvocationInfo myInvocation = null;
                     if (base2.Command != null)
                     {
                         myInvocation = base2.Command.MyInvocation;
                     }
                     ProviderInvocationException innerException = exception as ProviderInvocationException;
                     if (innerException != null)
                     {
                         exception = new CmdletProviderInvocationException(innerException, myInvocation);
                     }
                     else
                     {
                         exception = new CmdletInvocationException(exception, myInvocation);
                         MshLog.LogCommandHealthEvent(base2.Command.Context, exception, Severity.Warning);
                     }
                     this.RecordFailure(exception, base2.Command);
                 }
             }
         }
     }
     this._commands = null;
     if (this._redirectionPipes != null)
     {
         foreach (PipelineProcessor processor in this._redirectionPipes)
         {
             try
             {
                 if (processor != null)
                 {
                     processor.Dispose();
                 }
             }
             catch (Exception exception3)
             {
                 CommandProcessorBase.CheckForSevereException(exception3);
             }
         }
     }
     this._redirectionPipes = null;
 }
Beispiel #5
0
 internal static void CheckForSevereException(Cmdlet cmdlet, Exception e)
 {
     if (e as AccessViolationException != null || e as StackOverflowException != null)
     {
         try
         {
             if (!CommandsCommon.alreadyFailing)
             {
                 CommandsCommon.alreadyFailing = true;
                 MshLog.LogCommandHealthEvent(cmdlet.Context, e, Severity.Critical);
             }
         }
         finally
         {
             if (!CommandsCommon.designForTestability_SkipFailFast)
             {
                 WindowsErrorReporting.FailFast(e);
             }
         }
     }
 }
Beispiel #6
0
 internal static void CheckForSevereException(PSCmdlet cmdlet, Exception e)
 {
     if ((e is AccessViolationException) || (e is StackOverflowException))
     {
         try
         {
             if (!alreadyFailing)
             {
                 alreadyFailing = true;
                 ExecutionContext executionContext = (cmdlet != null) ? cmdlet.Context : LocalPipeline.GetExecutionContextFromTLS();
                 MshLog.LogCommandHealthEvent(executionContext, e, Severity.Critical);
             }
         }
         finally
         {
             if (!designForTestability_SkipFailFast)
             {
                 WindowsErrorReporting.FailFast(e);
             }
         }
     }
 }