/// <summary>Handles an exception before the response has been written out.</summary> /// <param name='exception'>Exception thrown.</param> /// <param name='service'>Data service doing the processing.</param> /// <param name='accept'>'Accept' header value; possibly null.</param> /// <param name='acceptCharset'>'Accept-Charset' header; possibly null.</param> /// <returns>An action that can serialize the exception into a stream.</returns> internal static Action <Stream> HandleBeforeWritingException(Exception exception, IDataService service, string accept, string acceptCharset) { Debug.Assert(WebUtil.IsCatchableExceptionType(exception), "WebUtil.IsCatchableExceptionType(exception)"); Debug.Assert(exception != null, "exception != null"); Debug.Assert(service != null, "service != null"); string contentType; Encoding encoding; TryGetResponseFormatForError(accept, acceptCharset, out contentType, out encoding); bool verbose = (service.Configuration != null) ? service.Configuration.UseVerboseErrors : false; HandleExceptionArgs args = new HandleExceptionArgs(exception, false, contentType, verbose); service.InternalHandleException(args); DataServiceHostWrapper host = service.OperationContext.Host; host.ResponseVersion = XmlConstants.DataServiceVersion1Dot0 + ";"; host.ProcessException(args); Action <Stream> action = ProcessBenignException(exception, service); if (action != null) { return(action); } else { return(CreateErrorSerializer(args, encoding)); } }
void IDataServiceHost.ProcessException(HandleExceptionArgs args) { WebUtil.CheckArgumentNull <HandleExceptionArgs>(args, "args"); this.responseStatusCode = args.ResponseStatusCode; this.responseHeaders[System.Net.HttpResponseHeader.ContentType] = args.ResponseContentType; this.responseHeaders[System.Net.HttpResponseHeader.Allow] = args.ResponseAllowHeader; }
/// <summary>Handles an exception when processing a batch response.</summary> /// <param name='service'>Data service doing the processing.</param> /// <param name="host">host to which we need to write the exception message</param> /// <param name='exception'>Exception thrown.</param> /// <param name='writer'>Output writer for the batch.</param> internal static void HandleBatchProcessException(IDataService service, DataServiceHostWrapper host, Exception exception, StreamWriter writer) { Debug.Assert(service != null, "service != null"); Debug.Assert(host != null, "host != null"); Debug.Assert(exception != null, "exception != null"); Debug.Assert(writer != null, "writer != null"); Debug.Assert(service.Configuration != null, "service.Configuration != null"); Debug.Assert(WebUtil.IsCatchableExceptionType(exception), "WebUtil.IsCatchableExceptionType(exception)"); string contentType; Encoding encoding; TryGetResponseFormatForError(host, out contentType, out encoding); HandleExceptionArgs args = new HandleExceptionArgs(exception, false, contentType, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); host.ResponseVersion = XmlConstants.DataServiceVersion1Dot0 + ";"; host.ProcessException(args); writer.Flush(); Action<Stream> errorWriter = ProcessBenignException(exception, service); if (errorWriter == null) { errorWriter = CreateErrorSerializer(args, encoding); } errorWriter(writer.BaseStream); writer.WriteLine(); }
/// <summary>Handles an exception when processing a batch response.</summary> /// <param name='service'>Data service doing the processing.</param> /// <param name="host">host to which we need to write the exception message</param> /// <param name='exception'>Exception thrown.</param> /// <param name='writer'>Output writer for the batch.</param> internal static void HandleBatchProcessException(IDataService service, DataServiceHostWrapper host, Exception exception, StreamWriter writer) { Debug.Assert(service != null, "service != null"); Debug.Assert(host != null, "host != null"); Debug.Assert(exception != null, "exception != null"); Debug.Assert(writer != null, "writer != null"); Debug.Assert(service.Configuration != null, "service.Configuration != null"); Debug.Assert(WebUtil.IsCatchableExceptionType(exception), "WebUtil.IsCatchableExceptionType(exception)"); string contentType; Encoding encoding; TryGetResponseFormatForError(host, out contentType, out encoding); HandleExceptionArgs args = new HandleExceptionArgs(exception, false, contentType, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); host.ResponseVersion = XmlConstants.DataServiceVersion1Dot0 + ";"; host.ProcessException(args); writer.Flush(); Action <Stream> errorWriter = ProcessBenignException(exception, service); if (errorWriter == null) { errorWriter = CreateErrorSerializer(args, encoding); } errorWriter(writer.BaseStream); writer.WriteLine(); }
/// <summary>Handles an exception when processing a batch request.</summary> /// <param name='service'>Data service doing the processing.</param> /// <param name='exception'>Exception thrown.</param> /// <param name='writer'>Output writer for the batch.</param> internal static void HandleBatchRequestException(IDataService service, Exception exception, StreamWriter writer) { Debug.Assert(service != null, "service != null"); Debug.Assert(exception != null, "exception != null"); Debug.Assert(writer != null, "writer != null"); Debug.Assert(service.Configuration != null, "service.Configuration != null - it should have been initialized by now"); Debug.Assert(WebUtil.IsCatchableExceptionType(exception), "WebUtil.IsCatchableExceptionType(exception) - "); string contentType; Encoding encoding; DataServiceHostWrapper host = service.OperationContext == null ? null : service.OperationContext.Host; TryGetResponseFormatForError(host, out contentType, out encoding); encoding = writer.Encoding; HandleExceptionArgs args = new HandleExceptionArgs(exception, false, contentType, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); writer.Flush(); Action <Stream> errorWriter = CreateErrorSerializer(args, encoding); errorWriter(writer.BaseStream); writer.WriteLine(); }
public void WriteException(HandleExceptionArgs args) { using (XmlWriter writer = XmlWriter.Create(this.outputStream)) { ErrorHandler.SerializeXmlError(args, writer); } }
internal static void HandleDuringWritingException(Exception exception, IDataService service, string contentType, ODataMessageWriter messageWriter, Stream responseStream, Encoding encoding) { HandleExceptionArgs args = new HandleExceptionArgs(exception, true, contentType, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); service.OperationContext.Host.ProcessException(args); SerializeODataError(args, messageWriter, responseStream, encoding); }
/// <summary>Serializes an error in XML format.</summary> /// <param name='args'>Arguments describing the error.</param> /// <param name='writer'>Writer to which error should be serialized.</param> internal static void SerializeXmlError(HandleExceptionArgs args, XmlWriter writer) { Debug.Assert(args != null, "args != null"); Debug.Assert(writer != null, "writer != null"); ErrorHandler serializer = new ErrorHandler(args, null); serializer.SerializeXmlError(writer); }
internal static void HandleDuringWritingException(Exception exception, IDataService service, string contentType, IExceptionWriter exceptionWriter) { HandleExceptionArgs args = new HandleExceptionArgs(exception, true, contentType, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); service.OperationContext.Host.ProcessException(args); exceptionWriter.WriteException(args); }
protected virtual void HandleException(HandleExceptionArgs args) { if (args == null) { throw new ArgumentNullException("args"); } throw new NotImplementedException(); }
private static Action<Stream> CreateErrorSerializer(ODataFormat responseFormat, HandleExceptionArgs args, Encoding encoding) { ErrorHandler handler = new ErrorHandler(args, encoding); if (responseFormat == ODataFormat.VerboseJson) { return new Action<Stream>(handler.SerializeJsonErrorToStream); } return new Action<Stream>(handler.SerializeXmlErrorToStream); }
void IDataServiceHost.ProcessException(HandleExceptionArgs args) { WebUtil.CheckArgumentNull<HandleExceptionArgs>(args, "args"); this.errorFound = true; if (!args.ResponseWritten) { ((IDataServiceHost) this).ResponseStatusCode = args.ResponseStatusCode; ((IDataServiceHost) this).ResponseContentType = args.ResponseContentType; if (args.ResponseAllowHeader != null) { WebOperationContext.Current.OutgoingResponse.Headers[HttpResponseHeader.Allow] = args.ResponseAllowHeader; } } }
/// <summary> /// Method to handle a data service exception during processing. /// </summary> /// <param name="args">Exception handling description.</param> void IDataServiceHost.ProcessException(HandleExceptionArgs args) { Debug.Assert(this.operationContext != null, "this.operationContext != null"); this.errorFound = true; if (!args.ResponseWritten) { ((IDataServiceHost)this).ResponseStatusCode = args.ResponseStatusCode; ((IDataServiceHost)this).ResponseContentType = args.ResponseContentType; if (args.ResponseAllowHeader != null) { this.operationContext.OutgoingResponse.Headers[HttpResponseHeader.Allow] = args.ResponseAllowHeader; } } }
void IDataServiceHost.ProcessException(HandleExceptionArgs args) { WebUtil.CheckArgumentNull <HandleExceptionArgs>(args, "args"); this.errorFound = true; if (!args.ResponseWritten) { ((IDataServiceHost)this).ResponseStatusCode = args.ResponseStatusCode; ((IDataServiceHost)this).ResponseContentType = args.ResponseContentType; if (args.ResponseAllowHeader != null) { WebOperationContext.Current.OutgoingResponse.Headers[HttpResponseHeader.Allow] = args.ResponseAllowHeader; } } }
/// <summary>Handles an exception while the response is being written out.</summary> /// <param name='exception'>Exception thrown.</param> /// <param name='service'>Data service doing the processing.</param> /// <param name='contentType'>MIME type of output stream.</param> /// <param name='exceptionWriter'>Serializer-specific exception writer.</param> internal static void HandleDuringWritingException(Exception exception, IDataService service, string contentType, IExceptionWriter exceptionWriter) { Debug.Assert(service != null, "service != null"); Debug.Assert(exception != null, "exception != null"); Debug.Assert(exceptionWriter != null, "exceptionWriter != null"); Debug.Assert(service.Configuration != null, "service.Configuration != null"); Debug.Assert(WebUtil.IsCatchableExceptionType(exception), "WebUtil.IsCatchableExceptionType(exception)"); HandleExceptionArgs args = new HandleExceptionArgs(exception, true, contentType, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); service.OperationContext.Host.ProcessException(args); exceptionWriter.WriteException(args); }
/// <summary>Creates a delegate that can serialize an error for the specified arguments.</summary> /// <param name="args">Arguments for the exception being handled.</param> /// <param name="encoding">Encoding to created over stream.</param> /// <returns>A delegate that can serialize an error for the specified arguments.</returns> private static Action <Stream> CreateErrorSerializer(HandleExceptionArgs args, Encoding encoding) { Debug.Assert(args != null, "args != null"); Debug.Assert(encoding != null, "encoding != null"); ErrorHandler handler = new ErrorHandler(args, encoding); if (WebUtil.CompareMimeType(args.ResponseContentType, XmlConstants.MimeApplicationJson)) { return(handler.SerializeJsonErrorToStream); } else { return(handler.SerializeXmlErrorToStream); } }
/// <summary>Method to handle a data service exception during processing.</summary> /// <param name="args">Exception handling description.</param> void IDataServiceHost.ProcessException(HandleExceptionArgs args) { // This would typically set headers on the host. WebUtil.CheckArgumentNull(args, "args"); Debug.Assert(WebUtil.IsCatchableExceptionType(args.Exception), "WebUtil.IsCatchableExceptionType(args.Exception)"); this.responseStatusCode = args.ResponseStatusCode; this.responseHeaders[HttpResponseHeader.ContentType] = args.ResponseContentType; this.responseHeaders[HttpResponseHeader.Allow] = args.ResponseAllowHeader; // Only write the headers if the response is not written if (!args.ResponseWritten) { System.Data.Services.Serializers.BatchWriter.WriteBoundaryAndHeaders(this.writer, this, this.contentId, this.boundary); } }
// public static void HandleException(HandleExceptionArgs args) { if (args.Exception.GetType() == typeof(DbEntityValidationException)) { var ex = args.Exception as DbEntityValidationException; args.Exception = new DataServiceException(500, ex.Message); } else { var message = GetExceptionMessgae(args.Exception); if (message != null) { args.Exception = new DataServiceException(500, message); } } }
internal static void HandleBatchInStreamError(IDataService service, Exception exception, ODataBatchWriter batchWriter, Stream responseStream) { string str; Encoding encoding; string str2; Version version; DataServiceHostWrapper host = (service.OperationContext == null) ? null : service.OperationContext.Host; TryGetResponseFormatForError(service, host, RequestDescription.DataServiceDefaultResponseVersion, out str, out encoding, out str2, out version); HandleExceptionArgs args = new HandleExceptionArgs(exception, false, str2, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); batchWriter.Flush(); using (XmlWriter writer = XmlUtil.CreateXmlWriterAndWriteProcessingInstruction(responseStream, encoding)) { ODataError error = CreateODataErrorFromExceptionArgs(args); ErrorUtils.WriteXmlError(writer, error, args.UseVerboseErrors, 100); } }
private static ODataError CreateODataErrorFromExceptionArgs(HandleExceptionArgs args) { string str; string str2; string str3; DataServiceException exception = ExtractErrorValues(args.Exception, out str, out str2, out str3); ODataError error = new ODataError { ErrorCode = str, Message = str2, MessageLanguage = str3 }; if (args.UseVerboseErrors) { Exception exception2 = (exception == null) ? args.Exception : exception.InnerException; error.InnerError = (exception2 == null) ? null : new ODataInnerError(exception2); } return error; }
private static ODataError CreateODataErrorFromExceptionArgs(HandleExceptionArgs args) { string str; string str2; string str3; DataServiceException exception = ExtractErrorValues(args.Exception, out str, out str2, out str3); ODataError error = new ODataError { ErrorCode = str, Message = str2, MessageLanguage = str3 }; if (args.UseVerboseErrors) { Exception exception2 = (exception == null) ? args.Exception : exception.InnerException; error.InnerError = (exception2 == null) ? null : new ODataInnerError(exception2); } return(error); }
internal static void HandleBatchInStreamError(IDataService service, Exception exception, ODataBatchWriter batchWriter, Stream responseStream) { string str; Encoding encoding; string str2; Version version; DataServiceHostWrapper host = (service.OperationContext == null) ? null : service.OperationContext.Host; TryGetResponseFormatForError(service, host, RequestDescription.DataServiceDefaultResponseVersion, out str, out encoding, out str2, out version); HandleExceptionArgs args = new HandleExceptionArgs(exception, false, str2, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); batchWriter.Flush(); using (XmlWriter writer = XmlUtil.CreateXmlWriterAndWriteProcessingInstruction(responseStream, encoding)) { ODataError error = CreateODataErrorFromExceptionArgs(args); ErrorUtils.WriteXmlError(writer, error, args.UseVerboseErrors, 100); } }
internal static void SerializeODataError(HandleExceptionArgs args, ODataMessageWriter writer, Stream outputStream, Encoding encoding) { ODataError error = CreateODataErrorFromExceptionArgs(args); try { writer.WriteError(error, args.UseVerboseErrors); } catch (InvalidOperationException) { if (!WebUtil.CompareMimeType(args.ResponseContentType, "application/json;odata=verbose")) { WebUtil.Dispose(writer); using (XmlWriter writer2 = XmlWriter.Create(outputStream, XmlUtil.CreateXmlWriterSettings(encoding))) { ErrorUtils.WriteXmlError(writer2, error, args.UseVerboseErrors, 100); } } } }
internal static void HandleBatchOperationError(IDataService service, DataServiceHostWrapper host, Exception exception, ODataBatchWriter batchWriter, Stream responseStream, Version defaultResponseVersion) { string str; Encoding encoding; string str2; Version version; TryGetResponseFormatForError(service, host, defaultResponseVersion, out str, out encoding, out str2, out version); HandleExceptionArgs args = new HandleExceptionArgs(exception, false, str2, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); Action <Stream> action = null; if (host != null) { host.ResponseVersion = version.ToString(2) + ";"; host.ProcessException(args); action = ProcessBenignException(exception, service); } if (action == null) { ODataBatchOperationResponseMessage operationResponseMessage; if (host != null) { operationResponseMessage = host.BatchServiceHost.GetOperationResponseMessage(); WebUtil.SetResponseHeadersForBatchRequests(operationResponseMessage, host.BatchServiceHost); } else { operationResponseMessage = batchWriter.CreateOperationResponseMessage(); operationResponseMessage.StatusCode = args.ResponseStatusCode; } using (ODataMessageWriter writer = ResponseBodyWriter.CreateMessageWriter(null, service, version, operationResponseMessage, str, null)) { SerializeODataError(args, writer, responseStream, encoding); } } }
internal static Action <Stream> HandleBeforeWritingException(Exception exception, IDataService service) { string str; Encoding encoding; string str2; Version responseVersion = null; DataServiceHostWrapper host = service.OperationContext.Host; TryGetResponseFormatForError(service, host, RequestDescription.DataServiceDefaultResponseVersion, out str, out encoding, out str2, out responseVersion); bool verboseResponse = (service.Configuration != null) ? service.Configuration.UseVerboseErrors : false; HandleExceptionArgs args = new HandleExceptionArgs(exception, false, str2, verboseResponse); service.InternalHandleException(args); host.ResponseVersion = responseVersion.ToString(2) + ";"; host.ProcessException(args); Action <Stream> action = ProcessBenignException(exception, service); ODataFormat atom = ODataFormat.Atom; if (WebUtil.GetContentFormat(str) == ContentFormat.VerboseJson) { atom = ODataFormat.VerboseJson; } return(action ?? CreateErrorSerializer(atom, args, encoding)); }
internal static Action<Stream> HandleBeforeWritingException(Exception exception, IDataService service) { string str; Encoding encoding; string str2; Version responseVersion = null; DataServiceHostWrapper host = service.OperationContext.Host; TryGetResponseFormatForError(service, host, RequestDescription.DataServiceDefaultResponseVersion, out str, out encoding, out str2, out responseVersion); bool verboseResponse = (service.Configuration != null) ? service.Configuration.UseVerboseErrors : false; HandleExceptionArgs args = new HandleExceptionArgs(exception, false, str2, verboseResponse); service.InternalHandleException(args); host.ResponseVersion = responseVersion.ToString(2) + ";"; host.ProcessException(args); Action<Stream> action = ProcessBenignException(exception, service); ODataFormat atom = ODataFormat.Atom; if (WebUtil.GetContentFormat(str) == ContentFormat.VerboseJson) { atom = ODataFormat.VerboseJson; } return (action ?? CreateErrorSerializer(atom, args, encoding)); }
/// <summary>Creates a delegate that can serialize an error for the specified arguments.</summary> /// <param name="args">Arguments for the exception being handled.</param> /// <param name="encoding">Encoding to created over stream.</param> /// <returns>A delegate that can serialize an error for the specified arguments.</returns> private static Action<Stream> CreateErrorSerializer(HandleExceptionArgs args, Encoding encoding) { Debug.Assert(args != null, "args != null"); Debug.Assert(encoding != null, "encoding != null"); ErrorHandler handler = new ErrorHandler(args, encoding); if (WebUtil.CompareMimeType(args.ResponseContentType, XmlConstants.MimeApplicationJson)) { return handler.SerializeJsonErrorToStream; } else { return handler.SerializeXmlErrorToStream; } }
void System.Data.Services.IDataService.InternalHandleException(HandleExceptionArgs args) { }
internal static void HandleBatchOperationError(IDataService service, DataServiceHostWrapper host, Exception exception, ODataBatchWriter batchWriter, Stream responseStream, Version defaultResponseVersion) { string str; Encoding encoding; string str2; Version version; TryGetResponseFormatForError(service, host, defaultResponseVersion, out str, out encoding, out str2, out version); HandleExceptionArgs args = new HandleExceptionArgs(exception, false, str2, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); Action<Stream> action = null; if (host != null) { host.ResponseVersion = version.ToString(2) + ";"; host.ProcessException(args); action = ProcessBenignException(exception, service); } if (action == null) { ODataBatchOperationResponseMessage operationResponseMessage; if (host != null) { operationResponseMessage = host.BatchServiceHost.GetOperationResponseMessage(); WebUtil.SetResponseHeadersForBatchRequests(operationResponseMessage, host.BatchServiceHost); } else { operationResponseMessage = batchWriter.CreateOperationResponseMessage(); operationResponseMessage.StatusCode = args.ResponseStatusCode; } using (ODataMessageWriter writer = ResponseBodyWriter.CreateMessageWriter(null, service, version, operationResponseMessage, str, null)) { SerializeODataError(args, writer, responseStream, encoding); } } }
/// <summary>Serializes exception information.</summary> /// <param name="args">Description of exception to serialize.</param> public abstract void WriteException(HandleExceptionArgs args);
internal static void SerializeODataError(HandleExceptionArgs args, ODataMessageWriter writer, Stream outputStream, Encoding encoding) { ODataError error = CreateODataErrorFromExceptionArgs(args); try { writer.WriteError(error, args.UseVerboseErrors); } catch (InvalidOperationException) { if (!WebUtil.CompareMimeType(args.ResponseContentType, "application/json;odata=verbose")) { WebUtil.Dispose(writer); using (XmlWriter writer2 = XmlWriter.Create(outputStream, XmlUtil.CreateXmlWriterSettings(encoding))) { ErrorUtils.WriteXmlError(writer2, error, args.UseVerboseErrors, 100); } } } }
private ErrorHandler(HandleExceptionArgs args, Encoding encoding) { this.exceptionArgs = args; this.encoding = encoding; }
/// <summary>Initializes a new <see cref="ErrorHandler"/> instance.</summary> /// <param name="args">Arguments for the exception being handled.</param> /// <param name="encoding">Encoding to created over stream; null if a higher-level writer will be provided.</param> private ErrorHandler(HandleExceptionArgs args, Encoding encoding) { Debug.Assert(args != null, "args != null"); this.exceptionArgs = args; this.encoding = encoding; }
/// <summary>Handles an exception while the response is being written out.</summary> /// <param name='exception'>Exception thrown.</param> /// <param name='service'>Data service doing the processing.</param> /// <param name='contentType'>MIME type of output stream.</param> /// <param name='exceptionWriter'>Serializer-specific exception writer.</param> internal static void HandleDuringWritingException(Exception exception, IDataService service, string contentType, IExceptionWriter exceptionWriter) { Debug.Assert(service != null, "service != null"); Debug.Assert(exception != null, "exception != null"); Debug.Assert(exceptionWriter != null, "exceptionWriter != null"); Debug.Assert(service.Configuration != null, "service.Configuration != null"); Debug.Assert(WebUtil.IsCatchableExceptionType(exception), "WebUtil.IsCatchableExceptionType(exception)"); HandleExceptionArgs args = new HandleExceptionArgs(exception, true, contentType, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); service.OperationContext.Host.ProcessException(args); exceptionWriter.WriteException(args); }
internal static void SerializeXmlError(HandleExceptionArgs args, XmlWriter writer) { new ErrorHandler(args, null).SerializeXmlError(writer); }
/// <summary>Serializes an error in XML format.</summary> /// <param name='args'>Arguments describing the error.</param> /// <param name='writer'>Writer to which error should be serialized.</param> internal static void SerializeXmlError(HandleExceptionArgs args, XmlWriter writer) { Debug.Assert(args != null, "args != null"); Debug.Assert(writer != null, "writer != null"); ErrorHandler serializer = new ErrorHandler(args, null); serializer.SerializeXmlError(writer); }
/// <summary>Handles an exception when processing a batch request.</summary> /// <param name='service'>Data service doing the processing.</param> /// <param name='exception'>Exception thrown.</param> /// <param name='writer'>Output writer for the batch.</param> internal static void HandleBatchRequestException(IDataService service, Exception exception, StreamWriter writer) { Debug.Assert(service != null, "service != null"); Debug.Assert(exception != null, "exception != null"); Debug.Assert(writer != null, "writer != null"); Debug.Assert(service.Configuration != null, "service.Configuration != null - it should have been initialized by now"); Debug.Assert(WebUtil.IsCatchableExceptionType(exception), "WebUtil.IsCatchableExceptionType(exception) - "); string contentType; Encoding encoding; DataServiceHostWrapper host = service.OperationContext == null ? null : service.OperationContext.Host; TryGetResponseFormatForError(host, out contentType, out encoding); encoding = writer.Encoding; HandleExceptionArgs args = new HandleExceptionArgs(exception, false, contentType, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); writer.Flush(); Action<Stream> errorWriter = CreateErrorSerializer(args, encoding); errorWriter(writer.BaseStream); writer.WriteLine(); }
internal static void HandleDuringWritingException(Exception exception, IDataService service, string contentType, IExceptionWriter exceptionWriter) { HandleExceptionArgs args = new HandleExceptionArgs(exception, true, contentType, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); service.OperationContext.Host.ProcessException(args); exceptionWriter.WriteException(args); }
internal static void HandleDuringWritingException(Exception exception, IDataService service, string contentType, ODataMessageWriter messageWriter, Stream responseStream, Encoding encoding) { HandleExceptionArgs args = new HandleExceptionArgs(exception, true, contentType, service.Configuration.UseVerboseErrors); service.InternalHandleException(args); service.OperationContext.Host.ProcessException(args); SerializeODataError(args, messageWriter, responseStream, encoding); }
/// <summary>Handles an exception before the response has been written out.</summary> /// <param name='exception'>Exception thrown.</param> /// <param name='service'>Data service doing the processing.</param> /// <param name='accept'>'Accept' header value; possibly null.</param> /// <param name='acceptCharset'>'Accept-Charset' header; possibly null.</param> /// <returns>An action that can serialize the exception into a stream.</returns> internal static Action<Stream> HandleBeforeWritingException(Exception exception, IDataService service, string accept, string acceptCharset) { Debug.Assert(WebUtil.IsCatchableExceptionType(exception), "WebUtil.IsCatchableExceptionType(exception)"); Debug.Assert(exception != null, "exception != null"); Debug.Assert(service != null, "service != null"); string contentType; Encoding encoding; TryGetResponseFormatForError(accept, acceptCharset, out contentType, out encoding); bool verbose = (service.Configuration != null) ? service.Configuration.UseVerboseErrors : false; HandleExceptionArgs args = new HandleExceptionArgs(exception, false, contentType, verbose); service.InternalHandleException(args); DataServiceHostWrapper host = service.OperationContext.Host; host.ResponseVersion = XmlConstants.DataServiceVersion1Dot0 + ";"; host.ProcessException(args); Action<Stream> action = ProcessBenignException(exception, service); if (action != null) { return action; } else { return CreateErrorSerializer(args, encoding); } }
private ErrorHandler(HandleExceptionArgs args, Encoding encoding) { this.exceptionArgs = args; this.encoding = encoding; }
/// <summary> /// Method to handle a data service exception during processing. /// </summary> /// <param name="args">Exception handling description.</param> void IDataServiceHost.ProcessException(HandleExceptionArgs args) { Debug.Assert(this.operationContext != null, "this.operationContext != null"); this.errorFound = true; if (!args.ResponseWritten) { ((IDataServiceHost)this).ResponseStatusCode = args.ResponseStatusCode; ((IDataServiceHost)this).ResponseContentType = args.ResponseContentType; if (args.ResponseAllowHeader != null) { this.operationContext.OutgoingResponse.Headers[HttpResponseHeader.Allow] = args.ResponseAllowHeader; } } }
internal static void SerializeXmlError(HandleExceptionArgs args, XmlWriter writer) { new ErrorHandler(args, null).SerializeXmlError(writer); }
/// <summary>Method to handle a data service exception during processing.</summary> /// <param name="args">Exception handling description.</param> internal void ProcessException(HandleExceptionArgs args) { this.host.ProcessException(args); }
public void ProcessException(HandleExceptionArgs args) { throw new NotImplementedException(); }
/// <summary> /// Handles a data service exception using information in the <paramref name="args"/> parameter. /// </summary> /// <param name="args"><see cref="T:System.Data.Services.HandleExceptionArgs"/> that contains information on the exception object.</param> public void ProcessException(HandleExceptionArgs args) { throw new Exception("OData exception", args.Exception); }
protected virtual new void HandleException(HandleExceptionArgs args) { Contract.Requires(args != null); }
public void ProcessException(HandleExceptionArgs args) { throw new NotImplementedException(); }
/// <summary>Method to handle a data service exception during processing.</summary> /// <param name="args">Exception handling description.</param> void IDataServiceHost.ProcessException(HandleExceptionArgs args) { // This would typically set headers on the host. WebUtil.CheckArgumentNull(args, "args"); Debug.Assert(WebUtil.IsCatchableExceptionType(args.Exception), "WebUtil.IsCatchableExceptionType(args.Exception)"); this.responseStatusCode = args.ResponseStatusCode; this.responseHeaders[HttpResponseHeader.ContentType] = args.ResponseContentType; this.responseHeaders[HttpResponseHeader.Allow] = args.ResponseAllowHeader; // Only write the headers if the response is not written if (!args.ResponseWritten) { System.Data.Services.Serializers.BatchWriter.WriteBoundaryAndHeaders(this.writer, this, this.contentId, this.boundary); } }
/// <summary>Initializes a new <see cref="ErrorHandler"/> instance.</summary> /// <param name="args">Arguments for the exception being handled.</param> /// <param name="encoding">Encoding to created over stream; null if a higher-level writer will be provided.</param> private ErrorHandler(HandleExceptionArgs args, Encoding encoding) { Debug.Assert(args != null, "args != null"); this.exceptionArgs = args; this.encoding = encoding; }
private static Action <Stream> CreateErrorSerializer(ODataFormat responseFormat, HandleExceptionArgs args, Encoding encoding) { ErrorHandler handler = new ErrorHandler(args, encoding); if (responseFormat == ODataFormat.VerboseJson) { return(new Action <Stream>(handler.SerializeJsonErrorToStream)); } return(new Action <Stream>(handler.SerializeXmlErrorToStream)); }
void IDataServiceHost.ProcessException(HandleExceptionArgs args) { WebUtil.CheckArgumentNull<HandleExceptionArgs>(args, "args"); this.responseStatusCode = args.ResponseStatusCode; this.responseHeaders[System.Net.HttpResponseHeader.ContentType] = args.ResponseContentType; this.responseHeaders[System.Net.HttpResponseHeader.Allow] = args.ResponseAllowHeader; }