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);
}