bool ProcessErrorWithHandlers(IChannel ch, Exception ex, out Message res) { res = null; foreach (var eh in owner.ErrorHandlers) { if (eh.HandleError(ex)) { return(true); // error is handled appropriately. } } Logger.Error("An error occured, to be handled", ex); foreach (var eh in owner.ErrorHandlers) { eh.ProvideFault(ex, owner.MessageVersion, ref res); } if (res == null) { var conv = ch.GetProperty <FaultConverter> () ?? FaultConverter.GetDefaultFaultConverter(owner.MessageVersion); if (!conv.TryCreateFaultMessage(ex, out res)) { res = Message.CreateMessage(owner.MessageVersion, new FaultCode("Receiver"), ex.Message, owner.MessageVersion.Addressing.FaultNamespace); } } return(false); }
protected override bool ProcessRequest(MessageProcessingContext mrc) { Exception ex = mrc.ProcessingException; DispatchRuntime dispatchRuntime = mrc.OperationContext.EndpointDispatcher.DispatchRuntime; //invoke all user handlers ChannelDispatcher channelDispatcher = dispatchRuntime.ChannelDispatcher; foreach (IErrorHandler handler in channelDispatcher.ErrorHandlers) { if (handler.HandleError(ex)) { break; } } FaultConverter fc = FaultConverter.GetDefaultFaultConverter(dispatchRuntime.ChannelDispatcher.MessageVersion); Message res = null; if (!fc.TryCreateFaultMessage(ex, out res)) { throw ex; } mrc.ReplyMessage = res; if (duplex != null) { mrc.Reply(duplex, true); } else { mrc.Reply(true); } return(false); }
/// <summary> /// Gets the property. /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public override T GetProperty <T>() { if (typeof(T) == typeof(FaultConverter)) { return(FaultConverter.GetDefaultFaultConverter(MessageVersion.Soap12WSAddressing10) as T); } return(base.GetProperty <T>()); }
protected override void Execute(CodeActivityContext context) { Message inMessage = this.Message.Get(context); if (inMessage == null) { throw FxTrace.Exception.AsError(new InvalidOperationException(SR.NullReplyMessageContractMismatch)); } if (inMessage.IsFault) { FaultConverter faultConverter = FaultConverter.GetDefaultFaultConverter(inMessage.Version); Exception exception = DeserializeFault(inMessage, faultConverter); // We simply throw the exception throw FxTrace.Exception.AsError(exception); } else { object[] outObjects; if (this.parameters != null) { outObjects = new object[this.parameters.Count]; } else { outObjects = Constants.EmptyArray; } object returnValue = this.Formatter.DeserializeReply(inMessage, outObjects); if (this.Result != null) { this.Result.Set(context, returnValue); } if (parameters != null) { for (int i = 0; i < this.parameters.Count; i++) { OutArgument outArgument = this.parameters[i]; Fx.Assert(outArgument != null, "Parameter cannot be null"); object obj = outObjects[i]; if (obj == null) { obj = ProxyOperationRuntime.GetDefaultParameterValue(outArgument.ArgumentType); } outArgument.Set(context, obj); } } } }
protected override void Execute(CodeActivityContext context) { object[] emptyArray; System.ServiceModel.Channels.Message inMessage = this.Message.Get(context); if (inMessage == null) { throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new InvalidOperationException(System.ServiceModel.Activities.SR.NullReplyMessageContractMismatch)); } if (inMessage.IsFault) { FaultConverter defaultFaultConverter = FaultConverter.GetDefaultFaultConverter(inMessage.Version); Exception exception = this.DeserializeFault(inMessage, defaultFaultConverter); throw System.ServiceModel.Activities.FxTrace.Exception.AsError(exception); } if (this.parameters != null) { emptyArray = new object[this.parameters.Count]; } else { emptyArray = System.ServiceModel.Activities.Constants.EmptyArray; } object obj2 = this.Formatter.DeserializeReply(inMessage, emptyArray); if (this.Result != null) { this.Result.Set(context, obj2); } if (this.parameters != null) { for (int i = 0; i < this.parameters.Count; i++) { OutArgument argument = this.parameters[i]; object defaultParameterValue = emptyArray[i]; if (defaultParameterValue == null) { defaultParameterValue = ProxyOperationRuntime.GetDefaultParameterValue(argument.ArgumentType); } argument.Set(context, defaultParameterValue); } } }
public override void Reply(Message message, TimeSpan timeout) { try { if (!message.IsFault && message.Headers.Action != Constants.WstIssueReplyAction) { message = SecureMessage(message); } source.Reply(message, timeout); } catch (Exception ex) { FaultConverter fc = FaultConverter.GetDefaultFaultConverter(msg.Version); Message fault; if (fc.TryCreateFaultMessage(ex, out fault)) { source.Reply(fault, timeout); } else { throw; } } }
void ProcessInputCore(IInputChannel input, Message message) { bool isReply = message != null && Contract.Operations.Any(od => (od.DeclaringContract.CallbackContractType == od.DeclaringContract.ContractType || !od.InCallbackContract) && od.Messages.Any(md => md.Action == message.Headers.Action)); if (isReply) { if (ReplyHandlerQueue.Count > 0) { if (isReply) { var h = ReplyHandlerQueue.Dequeue(); h(message); return; } } } if (message.IsFault) { Exception ex; var mf = MessageFault.CreateFault(message, 0x10000); if (FaultConverter.GetDefaultFaultConverter(message.Version).TryCreateException(message, mf, out ex)) // FIXME: get maxMessageSize somehow { throw ex; } else { throw new FaultException(mf); } } if (!MessageMatchesEndpointDispatcher(message, Runtime.CallbackDispatchRuntime.EndpointDispatcher)) { throw new EndpointNotFoundException(String.Format("The request message has the target '{0}' with action '{1}' which is not reachable in this service contract", message.Headers.To, message.Headers.Action)); } new InputOrReplyRequestProcessor(Runtime.CallbackDispatchRuntime, input).ProcessInput(message); }
protected override bool ProcessRequest(MessageProcessingContext mrc) { Exception ex = mrc.ProcessingException; DispatchRuntime dispatchRuntime = mrc.OperationContext.EndpointDispatcher.DispatchRuntime; //invoke all user handlers ChannelDispatcher channelDispatcher = dispatchRuntime.ChannelDispatcher; foreach (IErrorHandler handler in channelDispatcher.ErrorHandlers) { if (handler.HandleError(ex)) { break; } } // FIXME: remove them. FaultConverter also covers errors like EndpointNotFoundException, which this handler never covers. And checking converter twice is extraneous, so this part is just extraneous. // FIXME: actually everything is done in OperationInvokerHandler now... FaultConverter fc = FaultConverter.GetDefaultFaultConverter(dispatchRuntime.ChannelDispatcher.MessageVersion); Message res = null; if (!fc.TryCreateFaultMessage(ex, out res)) { throw ex; } mrc.ReplyMessage = res; if (duplex != null) { mrc.Reply(duplex, true); } else { mrc.Reply(true); } return(false); }
object Request(OperationDescription od, bool isAsync, ref object [] parameters, OperationContext context) { ClientOperation op = runtime.Operations [od.Name]; object [] inspections = new object [runtime.MessageInspectors.Count]; Message req = CreateRequest(op, parameters, context); for (int i = 0; i < inspections.Length; i++) { inspections [i] = runtime.MessageInspectors [i].BeforeSendRequest(ref req, this); } Message res = Request(req, OperationTimeout); if (res.IsFault) { var resb = res.CreateBufferedCopy(runtime.MaxFaultSize); MessageFault fault = MessageFault.CreateFault(resb.CreateMessage(), runtime.MaxFaultSize); var conv = OperationChannel.GetProperty <FaultConverter> () ?? FaultConverter.GetDefaultFaultConverter(res.Version); Exception ex; if (!conv.TryCreateException(resb.CreateMessage(), fault, out ex)) { if (fault.HasDetail) { Type detailType = typeof(ExceptionDetail); var freader = fault.GetReaderAtDetailContents(); DataContractSerializer ds = null; foreach (var fci in op.FaultContractInfos) { if (res.Headers.Action == fci.Action || fci.Serializer.IsStartObject(freader)) { detailType = fci.Detail; ds = fci.Serializer; break; } } if (ds == null) { ds = new DataContractSerializer(detailType); } var detail = ds.ReadObject(freader); ex = (Exception)Activator.CreateInstance(typeof(FaultException <>).MakeGenericType(detailType), new object [] { detail, fault.Reason, fault.Code, res.Headers.Action }); } if (ex == null) { ex = new FaultException(fault); } } throw ex; } for (int i = 0; i < inspections.Length; i++) { runtime.MessageInspectors [i].AfterReceiveReply(ref res, inspections [i]); } if (!op.DeserializeReply) { return(res); } if (isAsync && od.EndMethod != null) { var endParams = od.EndMethod.GetParameters(); parameters = new object [endParams.Length - 1]; } return(op.Formatter.DeserializeReply(res, parameters)); }
/// <summary> /// Converts fault to exception and throws it /// </summary> /// <param name="response">Response message</param> /// <param name="fault">Fault message</param> /// <param name="action">SOAP Action</param> /// <param name="version">Message Version</param> private static void ThrowIfFaultUnderstood( Message response, MessageFault fault, string action, MessageVersion version) { Exception exception; bool isSenderFault; bool isReceiverFault; FaultCode subCode; FaultConverter faultConverter = FaultConverter.GetDefaultFaultConverter(version); if (faultConverter.TryCreateException(response, fault, out exception)) { throw exception; } if (version.Envelope == EnvelopeVersion.Soap11) { isSenderFault = true; isReceiverFault = true; subCode = fault.Code; } else { isSenderFault = fault.Code.IsSenderFault; isReceiverFault = fault.Code.IsReceiverFault; subCode = fault.Code.SubCode; } if ((subCode != null) && (subCode.Namespace != null)) { if (isSenderFault) { if (string.Compare(subCode.Namespace, "http://schemas.microsoft.com/net/2005/12/windowscommunicationfoundation/dispatcher", StringComparison.Ordinal) == 0) { if (string.Compare(subCode.Name, "SessionTerminated", StringComparison.Ordinal) == 0) { throw new ChannelTerminatedException(fault.Reason.GetMatchingTranslation(CultureInfo.CurrentCulture).Text); } if (string.Compare(subCode.Name, "TransactionAborted", StringComparison.Ordinal) == 0) { throw new ProtocolException(fault.Reason.GetMatchingTranslation(CultureInfo.CurrentCulture).Text); } } } if (isReceiverFault && (string.Compare(subCode.Namespace, "http://schemas.microsoft.com/net/2005/12/windowscommunicationfoundation/dispatcher", StringComparison.Ordinal) == 0)) { if (string.Compare(subCode.Name, "InternalServiceFault", StringComparison.Ordinal) == 0) { if (fault.HasDetail) { ExceptionDetail detail = fault.GetDetail <ExceptionDetail>(); throw new FaultException <ExceptionDetail>(detail, fault.Reason, fault.Code, action); } throw new FaultException(fault, action); } if (string.Compare(subCode.Name, "DeserializationFailed", StringComparison.Ordinal) == 0) { throw new ProtocolException(fault.Reason.GetMatchingTranslation(CultureInfo.CurrentCulture).Text); } } } throw new FaultException(fault); }