/// <summary> /// Constructs a new instance of a ProviderInvocationException /// using the specified data /// </summary> /// /// <param name="resourceId"> /// The resource ID to use as the format message for the error. /// </param> /// /// <param name="resourceStr"> /// This is the message template string. /// </param> /// /// <param name="provider"> /// The provider information used when formatting the error message. /// </param> /// /// <param name="path"> /// The path used when formatting the error message. /// </param> /// /// <param name="e"> /// The exception that was thrown by the provider. This will be set as /// the ProviderInvocationException's InnerException and the message will /// be used when formatting the error message. /// </param> /// /// <param name="useInnerExceptionErrorMessage"> /// If true, the error record from the inner exception will be used if it contains one. /// If false, the error message specified by the resourceId will be used. /// </param> /// /// <returns> /// A new instance of a ProviderInvocationException. /// </returns> /// /// <exception cref="ProviderInvocationException"> /// Wraps <paramref name="e"/> in a ProviderInvocationException /// and then throws it. /// </exception> /// internal ProviderInvocationException NewProviderInvocationException( string resourceId, string resourceStr, ProviderInfo provider, string path, Exception e, bool useInnerExceptionErrorMessage) { // If the innerException was itself thrown by // ProviderBase.ThrowTerminatingError, it is already a // ProviderInvocationException, and we don't want to // re-wrap it. ProviderInvocationException pie = e as ProviderInvocationException; if (null != pie) { pie._providerInfo = provider; return(pie); } pie = new ProviderInvocationException(resourceId, resourceStr, provider, path, e, useInnerExceptionErrorMessage); // Log a provider health event MshLog.LogProviderHealthEvent( ExecutionContext, provider.Name, pie, Severity.Warning); return(pie); }
internal void WriteError(ErrorRecord errorRecord) { if (this.Stopping) { PipelineStoppedException exception = new PipelineStoppedException(); throw exception; } if (this.streamErrors) { if (this.command == null) { throw PSTraceSource.NewInvalidOperationException("SessionStateStrings", "ErrorStreamingNotEnabled", new object[0]); } tracer.WriteLine("Writing error package to command error pipe", new object[0]); this.command.WriteError(errorRecord); } else { this.accumulatedErrorObjects.Add(errorRecord); if ((errorRecord.ErrorDetails != null) && (errorRecord.ErrorDetails.TextLookupError != null)) { Exception textLookupError = errorRecord.ErrorDetails.TextLookupError; errorRecord.ErrorDetails.TextLookupError = null; MshLog.LogProviderHealthEvent(this.ExecutionContext, this.ProviderInstance.ProviderInfo.Name, textLookupError, Severity.Warning); } } }
} // WriteObject /// <summary> /// Writes the error to the pipeline or accumulates the error in an internal /// buffer. /// </summary> /// <param name="errorRecord"> /// The error record to write to the pipeline or the internal buffer. /// </param> /// <exception cref="InvalidOperationException"> /// The CmdletProvider could not stream the error because no /// cmdlet was specified to stream the output through. /// </exception> /// <exception cref="PipelineStoppedException"> /// If the pipeline has been signaled for stopping but /// the provider calls this method. /// </exception> internal void WriteError(ErrorRecord errorRecord) { // Making sure to obey the StopProcessing by // throwing an exception anytime a provider tries // to WriteError if (Stopping) { PipelineStoppedException stopPipeline = new PipelineStoppedException(); throw stopPipeline; } if (_streamErrors) { if (_command != null) { s_tracer.WriteLine("Writing error package to command error pipe"); _command.WriteError(errorRecord); } else { InvalidOperationException e = PSTraceSource.NewInvalidOperationException( SessionStateStrings.ErrorStreamingNotEnabled); throw e; } } else { // Since we are not streaming, just add the object to the accumulatedErrorObjects _accumulatedErrorObjects.Add(errorRecord); if (errorRecord.ErrorDetails != null && errorRecord.ErrorDetails.TextLookupError != null) { Exception textLookupError = errorRecord.ErrorDetails.TextLookupError; errorRecord.ErrorDetails.TextLookupError = null; MshLog.LogProviderHealthEvent( this.ExecutionContext, this.ProviderInstance.ProviderInfo.Name, textLookupError, Severity.Warning); } } } // WriteError
/// <summary> /// If there are any errors accumulated, the first error is thrown. /// </summary> /// <param name="wrapExceptionInProviderException"> /// If true, the error will be wrapped in a ProviderInvocationException before /// being thrown. If false, the error will be thrown as is. /// </param> /// <exception cref="ProviderInvocationException"> /// If <paramref name="wrapExceptionInProviderException"/> is true, the /// first exception that was written to the error pipeline by a CmdletProvider /// is wrapped and thrown. /// </exception> /// <exception> /// If <paramref name="wrapExceptionInProviderException"/> is false, /// the first exception that was written to the error pipeline by a CmdletProvider /// is thrown. /// </exception> internal void ThrowFirstErrorOrDoNothing(bool wrapExceptionInProviderException) { if (HasErrors()) { Collection <ErrorRecord> errors = GetAccumulatedErrorObjects(); if (errors != null && errors.Count > 0) { // Throw the first exception if (wrapExceptionInProviderException) { ProviderInfo providerInfo = null; if (this.ProviderInstance != null) { providerInfo = this.ProviderInstance.ProviderInfo; } ProviderInvocationException e = new ProviderInvocationException( providerInfo, errors[0]); // Log a provider health event MshLog.LogProviderHealthEvent( this.ExecutionContext, providerInfo != null ? providerInfo.Name : "unknown provider", e, Severity.Warning); throw e; } else { throw errors[0].Exception; } } } }
internal void ThrowFirstErrorOrDoNothing(bool wrapExceptionInProviderException) { if (this.HasErrors()) { Collection <ErrorRecord> accumulatedErrorObjects = this.GetAccumulatedErrorObjects(); if ((accumulatedErrorObjects != null) && (accumulatedErrorObjects.Count > 0)) { if (!wrapExceptionInProviderException) { throw accumulatedErrorObjects[0].Exception; } ProviderInfo provider = null; if (this.ProviderInstance != null) { provider = this.ProviderInstance.ProviderInfo; } ProviderInvocationException exception = new ProviderInvocationException(provider, accumulatedErrorObjects[0]); MshLog.LogProviderHealthEvent(this.ExecutionContext, (provider != null) ? provider.Name : "unknown provider", exception, Severity.Warning); throw exception; } } }