private void ThrowIfFaultMessage(Message wcfMessage) { Exception exception; if (wcfMessage.IsFault) { MessagingClientEtwProvider.TraceClient(() => { }); string action = wcfMessage.Headers.Action; MessageFault messageFault = MessageFault.CreateFault(wcfMessage, 65536); FaultConverter property = this.innerChannel.GetProperty <FaultConverter>(); if (property == null || !property.TryCreateException(wcfMessage, messageFault, out exception)) { if (!messageFault.HasDetail) { throw Microsoft.ServiceBus.Messaging.FxTrace.Exception.AsWarning(new FaultException(messageFault, action), null); } ExceptionDetail detail = messageFault.GetDetail <ExceptionDetail>(); if (!this.clientMode && string.Equals(detail.Type, typeof(CommunicationException).FullName, StringComparison.Ordinal)) { MessagingClientEtwProvider.TraceClient(() => MessagingClientEtwProvider.Provider.EventWriteRuntimeChannelFaulting(this.innerChannel.GetType().Name, this.innerChannel.LocalAddress.Uri.AbsoluteUri, this.innerChannel.RemoteAddress.Uri.AbsoluteUri, this.innerChannel.Via.AbsoluteUri, this.innerChannel.Session.Id, string.Concat("ThrowIfFaultMessage: Received CommunicationException as fault message. ", detail.ToString()))); base.Fault(); } if (!this.includeExceptionDetails) { throw Microsoft.ServiceBus.Messaging.FxTrace.Exception.AsInformation(new FaultException <ExceptionDetailNoStackTrace>(new ExceptionDetailNoStackTrace(detail, true), messageFault.Reason, messageFault.Code, action), null); } throw Microsoft.ServiceBus.Messaging.FxTrace.Exception.AsInformation(new FaultException <ExceptionDetail>(detail, messageFault.Reason, messageFault.Code, action), null); } throw Fx.Exception.AsWarning(exception, null); } }
Exception DeserializeFault(Message inMessage, FaultConverter faultConverter) { // Reproduce logic in ClientOperationFormatterHelper MessageFault messageFault = MessageFault.CreateFault(inMessage, TransportDefaults.MaxFaultSize); string action = inMessage.Headers.Action; if (action == inMessage.Version.Addressing.DefaultFaultAction) { action = null; } Exception exception = null; if (faultConverter != null) { faultConverter.TryCreateException(inMessage, messageFault, out exception); } if (exception == null) { exception = this.FaultFormatter.Deserialize(messageFault, action); } if (inMessage.State != MessageState.Created) { inMessage.Close(); } return(exception); }
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); } } } }
internal void ProvideFault(Exception e, FaultConverter faultConverter, ref ErrorHandlerFaultInfo faultInfo) { ProvideWellKnownFault(e, faultConverter, ref faultInfo); for (int i = 0; i < handlers.Length; i++) { Message m = faultInfo.Fault; handlers[i].ProvideFault(e, messageVersion, ref m); faultInfo.Fault = m; //if (TD.FaultProviderInvokedIsEnabled()) //{ // TD.FaultProviderInvoked(handlers[i].GetType().FullName, e.Message); //} } ProvideFaultOfLastResort(e, ref faultInfo); }
internal void ProvideFault(Exception e, FaultConverter faultConverter, ref ErrorHandlerFaultInfo faultInfo) { this.ProvideWellKnownFault(e, faultConverter, ref faultInfo); for (int i = 0; i < this.handlers.Length; i++) { Message fault = faultInfo.Fault; this.handlers[i].ProvideFault(e, this.messageVersion, ref fault); faultInfo.Fault = fault; if (TD.FaultProviderInvokedIsEnabled()) { TD.FaultProviderInvoked(this.handlers[i].GetType().FullName, e.Message); } } this.ProvideFaultOfLastResort(e, ref faultInfo); }
internal void ProvideFault(Exception e, FaultConverter faultConverter, ref ErrorHandlerFaultInfo faultInfo) { ProvideWellKnownFault(e, faultConverter, ref faultInfo); for (int i = 0; i < _handlers.Length; i++) { Message m = faultInfo.Fault; _handlers[i].ProvideFault(e, _messageVersion, ref m); faultInfo.Fault = m; if (WcfEventSource.Instance.FaultProviderInvokedIsEnabled()) { WcfEventSource.Instance.FaultProviderInvoked(_handlers[i].GetType().FullName, e.Message); } } this.ProvideFaultOfLastResort(e, ref faultInfo); }
internal void ProvideFault(Exception e, FaultConverter faultConverter, ref ErrorHandlerFaultInfo faultInfo) { ErrorBehavior errorBehavior; lock (base.ThisLock) { if (this.errorBehavior != null) { errorBehavior = this.errorBehavior; } else { errorBehavior = new ErrorBehavior(this); } } errorBehavior.ProvideFault(e, faultConverter, ref faultInfo); }
// TODO: Move this functionality somewhere else as this class is now OM only internal void ProvideFault(Exception e, FaultConverter faultConverter, ref ErrorHandlerFaultInfo faultInfo) { ErrorBehavior behavior; lock (ThisLock) { if (_errorBehavior != null) { behavior = _errorBehavior; } else { behavior = new ErrorBehavior(this); } } behavior.ProvideFault(e, faultConverter, ref faultInfo); }
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); } } }
protected override bool OnTryCreateFaultMessage(Exception exception, out Message message) { if (_innerChannel == null) { message = null; return(false); } FaultConverter inner = _innerChannel.GetProperty <FaultConverter>(); if (inner != null) { return(inner.TryCreateFaultMessage(exception, out message)); } else { message = null; return(false); } }
protected override bool OnTryCreateException(Message message, MessageFault fault, out Exception exception) { if (_innerChannel == null) { exception = null; return(false); } FaultConverter inner = _innerChannel.GetProperty <FaultConverter>(); if (inner != null) { return(inner.TryCreateException(message, fault, out exception)); } else { exception = null; return(false); } }
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; } } }
private void ProvideWellKnownFault(Exception e, FaultConverter faultConverter, ref ErrorHandlerFaultInfo faultInfo) { if (faultConverter != null && faultConverter.TryCreateFaultMessage(e, out Message faultMessage)) { faultInfo.Fault = faultMessage; return; } else if (e is NetDispatcherFaultException) { NetDispatcherFaultException ndfe = e as NetDispatcherFaultException; if (_debug) { ExceptionDetail detail = new ExceptionDetail(ndfe); faultInfo.Fault = Message.CreateMessage(_messageVersion, MessageFault.CreateFault(ndfe.Code, ndfe.Reason, detail), ndfe.Action); } else { faultInfo.Fault = Message.CreateMessage(_messageVersion, ndfe.CreateMessageFault(), ndfe.Action); } } }
private void ProvideWellKnownFault(Exception e, FaultConverter faultConverter, ref ErrorHandlerFaultInfo faultInfo) { Message message; if ((faultConverter != null) && faultConverter.TryCreateFaultMessage(e, out message)) { faultInfo.Fault = message; } else if (e is NetDispatcherFaultException) { NetDispatcherFaultException exception = e as NetDispatcherFaultException; if (this.debug) { ExceptionDetail detail = new ExceptionDetail(exception); faultInfo.Fault = Message.CreateMessage(this.messageVersion, MessageFault.CreateFault(exception.Code, exception.Reason, detail), exception.Action); } else { faultInfo.Fault = Message.CreateMessage(this.messageVersion, exception.CreateMessageFault(), exception.Action); } } }
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)); }
private Exception DeserializeFault(System.ServiceModel.Channels.Message inMessage, FaultConverter faultConverter) { MessageFault fault = MessageFault.CreateFault(inMessage, 0x10000); string action = inMessage.Headers.Action; if (action == inMessage.Version.Addressing.DefaultFaultAction) { action = null; } Exception exception = null; if (faultConverter != null) { faultConverter.TryCreateException(inMessage, fault, out exception); } if (exception == null) { exception = this.FaultFormatter.Deserialize(fault, action); } if (inMessage.State != MessageState.Created) { inMessage.Close(); } return(exception); }
public static List <Fault> GetFaultByBuilding(int buildingId) { return(FaultConverter.ListToDTO(FaultDAL.GetFaultByBuilding(buildingId))); }
public static void UpdateFaultStatus(Fault f) { FaultDAL.UpdateStatus(FaultConverter.ToDAL(f)); }
public static void AddFault(Fault fault) { FaultDAL.Add(FaultConverter.ToDAL(fault)); }
public static List <Fault> GetAll() { return(FaultConverter.ListToDTO(FaultDAL.Get())); }
public static Fault GetById(int id) { return(FaultConverter.ToDTO(FaultDAL.GetById(id))); }
/// <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); }