public Microsoft.ServiceBus.Channels.IConnection Connect(Uri uri, TimeSpan timeout) { EventTraceActivity eventTraceActivity = new EventTraceActivity(); TimeoutHelper timeoutHelper = new TimeoutHelper(timeout); WebStream webStream = (new WebStream(uri, "connection", this.useHttpsMode, eventTraceActivity, uri)).Open(); Microsoft.ServiceBus.Channels.IConnection webStreamConnection = new WebStreamConnection(uri, this.bufferSize, eventTraceActivity, webStream, uri); webStreamConnection = SecureSocketUtil.InitiateSecureClientUpgradeIfNeeded(webStreamConnection, null, this.socketSecurityRole, uri.Host, timeoutHelper.RemainingTime()); SocketMessageHelper socketMessageHelper = new SocketMessageHelper(); Message message = Message.CreateMessage(socketMessageHelper.MessageVersion, "RelayedConnect", new ConnectMessage(uri)); TrackingIdHeader.TryAddOrUpdate(message.Headers, eventTraceActivity.ActivityId.ToString()); if (this.tokenProvider != null) { string absoluteUri = RelayedHttpUtility.ConvertToHttpUri(uri).AbsoluteUri; SecurityToken token = this.tokenProvider.GetToken(absoluteUri, "Send", false, timeoutHelper.RemainingTime()); message.Headers.Add(new RelayTokenHeader(token)); } socketMessageHelper.SendMessage(webStreamConnection, message, timeoutHelper.RemainingTime()); Message message1 = socketMessageHelper.ReceiveMessage(webStreamConnection, timeoutHelper.RemainingTime()); if (message1.IsFault) { throw ErrorUtility.ConvertToError(MessageFault.CreateFault(message1, 65536)); } return(webStreamConnection); }
/// <summary> /// Gets the metadata set from the Resource Management Service /// </summary> /// <returns></returns> private static MetadataSet GetMetadataSet(EndpointManager e) { MetadataSet set; GetMetadata body = new GetMetadata(); body.Dialect = Namespaces.XmlSchema; body.Identifier = string.Format("xs:schema/{0}", Namespaces.ResourceManagement); Message requestMessage = Message.CreateMessage(MessageVersion.Default, Namespaces.Get, new SerializerBodyWriter(body)); Binding httpBinding = BindingManager.GetWsHttpBinding(); ResourceManagementService.MetadataExchangeClient mex = new ResourceManagementService.MetadataExchangeClient(httpBinding, e.MetadataEndpoint); Message responseMessage = mex.Get(requestMessage); if (responseMessage.IsFault) { // We shouldn't get here as the WCF framework should convert the fault into an exception MessageFault fault = MessageFault.CreateFault(responseMessage, Int32.MaxValue); throw new FaultException(fault); } set = responseMessage.GetBody <MetadataSet>(); return(set); }
private void Fault(Message message) { try { MessageFault fault = MessageFault.CreateFault(message, 0x10000); if (DebugTrace.Verbose) { FaultCode baseFaultCode = Library.GetBaseFaultCode(fault); DebugTrace.Trace(TraceLevel.Verbose, "Dispatching participant completion fault {0}", (baseFaultCode == null) ? "unknown" : baseFaultCode.Name); if (DebugTrace.Pii) { DebugTrace.TracePii(TraceLevel.Verbose, "Sender is {0}", CoordinationServiceSecurity.GetSenderName(message)); } } this.dispatch.Fault(message, fault); } catch (CommunicationException exception) { Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning); base.OnMessageException(message, exception); } catch (Exception exception2) { DebugTrace.Trace(TraceLevel.Error, "Unhandled exception {0} dispatching completion fault from participant: {1}", exception2.GetType().Name, exception2); Microsoft.Transactions.Bridge.DiagnosticUtility.InvokeFinalHandler(exception2); } }
private void ProvideFaultOfLastResort(Exception error, ref ErrorHandlerFaultInfo faultInfo) { if (faultInfo.Fault == null) { MessageFault fault; FaultCode subCode = new FaultCode("InternalServiceFault", "http://schemas.microsoft.com/net/2005/12/windowscommunicationfoundation/dispatcher"); subCode = FaultCode.CreateReceiverFaultCode(subCode); string action = "http://schemas.microsoft.com/net/2005/12/windowscommunicationfoundation/dispatcher/fault"; if (this.debug) { faultInfo.DefaultFaultAction = action; fault = MessageFault.CreateFault(subCode, new FaultReason(error.Message), new ExceptionDetail(error)); } else { string text = this.isOnServer ? System.ServiceModel.SR.GetString("SFxInternalServerError") : System.ServiceModel.SR.GetString("SFxInternalCallbackError"); fault = MessageFault.CreateFault(subCode, new FaultReason(text)); } faultInfo.IsConsideredUnhandled = true; faultInfo.Fault = Message.CreateMessage(this.messageVersion, fault, action); } else if (error != null) { FaultException exception = error as FaultException; if ((((exception != null) && (exception.Fault != null)) && ((exception.Fault.Code != null) && (exception.Fault.Code.SubCode != null))) && ((string.Compare(exception.Fault.Code.SubCode.Namespace, "http://schemas.microsoft.com/net/2005/12/windowscommunicationfoundation/dispatcher", StringComparison.Ordinal) == 0) && (string.Compare(exception.Fault.Code.SubCode.Name, "InternalServiceFault", StringComparison.Ordinal) == 0))) { faultInfo.IsConsideredUnhandled = true; } } }
private static MessagePartSpecification ExtractMessageParts(string action, ScopedMessagePartSpecification scopedParts, bool isForSignature) { MessagePartSpecification parts = null; if (scopedParts.TryGetParts(action, out parts)) { return(parts); } else if (scopedParts.TryGetParts(MessageHeaders.WildcardAction, out parts)) { return(parts); } // send back a fault indication that the action is unknown SecurityVersion wss = MessageSecurityVersion.Default.SecurityVersion; FaultCode subCode = new FaultCode(wss.InvalidSecurityFaultCode.Value, wss.HeaderNamespace.Value); FaultCode senderCode = FaultCode.CreateSenderFaultCode(subCode); FaultReason reason = new FaultReason(SR.Format(SR.InvalidOrUnrecognizedAction, action), System.Globalization.CultureInfo.CurrentCulture); MessageFault fault = MessageFault.CreateFault(senderCode, reason); if (isForSignature) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.Format(SR.NoSignaturePartsSpecified, action), null, fault)); } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.Format(SR.NoEncryptionPartsSpecified, action), null, fault)); } }
/// <summary> /// Factory used to create the expected <see cref="MessageFault"/> to be used when returning this fault type. /// </summary> /// <param name="fault">The <see cref="ServiceUnavailableFault"/> to create a <see cref="MessageFault"/> from.</param> /// <returns>The appropriate <see cref="MessageFault"/> for the supplied <see cref="ServiceUnavailableFault"/>.</returns> public static MessageFault CreateStandardFault(ServiceUnavailableFault fault) { var faultCode = CreateStandardCode(); var faultReason = CreateStandardReason(); return(MessageFault.CreateFault(faultCode, faultReason, fault)); }
static void CallGeneric(GenericClient genericClient, string action, XmlNode messageBody) { // Build the message Message response; Message request; request = Message.CreateMessage( MessageVersion.Default, action, new XmlNodeReader(messageBody)); // send request response = genericClient.Request(request); // dump the result if (!response.IsFault) { XmlReader resultBody = response.GetReaderAtBodyContents(); resultBody.ReadToDescendant("text", "http://Microsoft.ServiceModel.Samples"); string responseText = resultBody.ReadElementContentAsString("text", "http://Microsoft.ServiceModel.Samples"); Console.WriteLine(responseText); } else { MessageFault fault = MessageFault.CreateFault(response, 8192); throw new FaultException(fault); } Console.WriteLine(); }
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 void TryCreateExceptionDefault() { var msg = Message.CreateMessage(XmlReader.Create(new StringReader(xml1)), 0x1000, MessageVersion.Soap11WSAddressing10); var mf = MessageFault.CreateFault(msg, 1000); msg = Message.CreateMessage(XmlReader.Create(new StringReader(xml1)), 0x1000, MessageVersion.Soap11WSAddressing10); Exception ex; Assert.IsTrue(s11.TryCreateException(msg, mf, out ex), "#1"); // foobar -> false Assert.IsFalse(s11.TryCreateException(msg, MessageFault.CreateFault(new FaultCode("foobar"), new FaultReason("foobar reason")), out ex), "#2"); // SOAP 1.1 ActionNotSupported -> true Assert.IsTrue(s11.TryCreateException(msg, MessageFault.CreateFault(new FaultCode("ActionNotSupported", Constants.WsaNamespace), new FaultReason("foobar reason")), out ex), "#3"); Assert.IsTrue(ex is ActionNotSupportedException, "#3-2"); Assert.IsTrue(ex.Message.IndexOf("foobar") >= 0, "#3-3"); // SOAP 1.1 Sender/ActionNotSupported -> false mf = MessageFault.CreateFault(new FaultCode("Sender", new FaultCode("ActionNotSupported", Constants.WsaNamespace)), new FaultReason("foobar reason")); Assert.IsFalse(s11.TryCreateException(msg, mf, out ex), "#4"); // SOAP 1.2 ActionNotSupported -> false mf = MessageFault.CreateFault(new FaultCode("ActionNotSupported", Constants.WsaNamespace), new FaultReason("foobar reason")); Assert.IsFalse(s12.TryCreateException(msg, mf, out ex), "#5"); // SOAP 1.2 Sender/ActionNotSupported -> true mf = MessageFault.CreateFault(new FaultCode("Sender", new FaultCode("ActionNotSupported", Constants.WsaNamespace)), new FaultReason("foobar reason")); Assert.IsTrue(s12.TryCreateException(msg, mf, out ex), "#6"); Assert.IsTrue(ex is ActionNotSupportedException, "#6-2"); Assert.IsTrue(ex.Message.IndexOf("foobar") >= 0, "#6-3"); }
/// <summary> /// Factory used to create the expected <see cref="MessageFault"/> to be used when returning this fault type. /// </summary> /// <param name="fault">The <see cref="ActionNotSupportedFault"/> to create a <see cref="MessageFault"/> from.</param> /// <returns>The appropriate <see cref="MessageFault"/> for the supplied <see cref="SlaViolationFault"/>.</returns> public static MessageFault CreateStandardFault(ActionNotSupportedFault fault) { var faultCode = CreateStandardCode(); var faultReason = CreateStandardReason(); return(MessageFault.CreateFault(faultCode, faultReason, fault)); }
public int GetFactorialNumber(int number) { if (number <= 0) { throw new FaultException( MessageFault.CreateFault( FaultCode.CreateSenderFaultCode( new FaultCode( "E01", "www.google.com" ) ), new FaultReason( new FaultReasonText( "Number should be greater than zero", CultureInfo.CurrentUICulture ) ) ) , "Check the fault reason"); } if (number == 1) { return(1); } return(number * GetFactorialNumber(--number)); }
private static void SetCommunicationStatusFlags(ref Message reply, IRuntime runtime) { if (!reply.IsFault) { return; } try { var buffer = reply.CreateBufferedCopy(int.MaxValue); var copy = buffer.CreateMessage(); if (!copy.IsFault) { return; } var fault = MessageFault.CreateFault(copy, int.MaxValue); var error = fault.Reason.GetMatchingTranslation().Text; reply = buffer.CreateMessage(); var exception = new CommunicationException(error); SetConnectivityErrorFlag(exception, runtime); } catch (Exception ex) { SetConnectivityErrorFlag(ex, runtime); } }
static ProtocolException CreateReceiveShutdownReturnedNonNull(Message message) { if (message.IsFault) { try { MessageFault fault = MessageFault.CreateFault(message, 64 * 1024); FaultReasonText reason = fault.Reason.GetMatchingTranslation(CultureInfo.CurrentCulture); string text = String.Format(ExceptionMessages.ReceiveShutdownReturnedFault, reason.Text); return(new ProtocolException(text)); } catch (QuotaExceededException) { string text = String.Format(ExceptionMessages.ReceiveShutdownReturnedLargeFault, message.Headers.Action); return(new ProtocolException(text)); } } else { string text = String.Format(ExceptionMessages.ReceiveShutdownReturnedMessage, message.Headers.Action); return(new ProtocolException(text)); } }
public void RunBasicFaultTest() { for ( MessageVersion version = MessageVersion.Soap11; version != null; version = (version == MessageVersion.Soap11) ? MessageVersion.Soap12WSAddressing10 : null ) { var translations = new List <FaultReasonText> { new FaultReasonText("Reason: auto-generated fault for testing.", "en-us"), new FaultReasonText("Raison: auto-generat error pour examiner.", "fr") }; var reason = new FaultReason(translations); object detail = "Sample fault detail content."; MessageFault fault = MessageFault.CreateFault(new FaultCode("Sender"), reason, detail, new System.Runtime.Serialization.DataContractSerializer(typeof(string)), "", ""); Message message = Message.CreateMessage(MessageVersion.Soap12WSAddressing10, fault, "http://www.w3.org/2005/08/addressing/fault"); Message m2 = MessageTestUtilities.SendAndReceiveMessage(message); MessageFault f2 = MessageFault.CreateFault(m2, int.MaxValue); IsFaultEqual(fault, f2); } }
public void TestCreateMessageFault() { EmptyFaultException e = new EmptyFaultException(); Assert.IsTrue( AreEqual(MessageFault.CreateFault(e.Code, e.Reason), e.CreateMessageFault())); }
private void ValidateReply(Message reply, string replyAction) { if (base.interoperating) { if (!base.coordinationService.Security.CheckIdentity(this, reply)) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatReceiveFailureException(Microsoft.Transactions.SR.GetString("ReplyServerCredentialMismatch"))); } if (!base.coordinationService.GlobalAcl.AccessCheckReply(reply, BindingStrings.InteropBindingQName(base.protocolVersion))) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatReceiveFailureException(Microsoft.Transactions.SR.GetString("ReplyServerIdentityAccessDenied", new object[] { base.to.Uri }))); } } string action = reply.Headers.Action; if ((reply.IsFault || (action == base.atomicTransactionStrings.FaultAction)) || (action == base.coordinationStrings.FaultAction)) { MessageFault fault = MessageFault.CreateFault(reply, 0x10000); throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatFaultException(fault, action)); } if (action != replyAction) { throw Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new WsatReceiveFailureException(Microsoft.Transactions.SR.GetString("InvalidMessageAction", new object[] { action }))); } }
public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { FaultException <DomainServiceFault> faultError = error as FaultException <DomainServiceFault>; if (faultError != null) { if (this.format == WebContentFormat.Json) { // Create a fault message containing our FaultContract object. fault = Message.CreateMessage(version, faultError.Action, faultError.Detail, new DataContractJsonSerializer(faultError.Detail.GetType())); fault.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(this.format)); // Return custom error code. var rmp = new HttpResponseMessageProperty(); rmp.StatusCode = System.Net.HttpStatusCode.InternalServerError; rmp.Headers[System.Net.HttpResponseHeader.ContentType] = "text/json"; fault.Properties.Add(HttpResponseMessageProperty.Name, rmp); } else { // serialize in the SOAP fault format so that Silverlight throws the right exception MessageFault messageFault = MessageFault.CreateFault(faultError.Code, faultError.Reason, faultError.Detail); fault = Message.CreateMessage(MessageVersion.None, messageFault, null); var rmp = new HttpResponseMessageProperty(); rmp.StatusCode = System.Net.HttpStatusCode.OK; fault.Properties.Add(HttpResponseMessageProperty.Name, rmp); } } }
private Message TransformOutputMessage(Message value, MessageVersion clientMsgVersion) { Message toSend; if (value.Version == clientMsgVersion) { toSend = value; } else { if (value.IsFault) { MessageFault fault = MessageFault.CreateFault(value, 100000); MessageFault fault2 = MessageFault.CreateFault(fault.Code, fault.Reason); toSend = Message.CreateMessage( clientMsgVersion, //versione fault2, value.Headers.Action); } else { //trasforma il messaggio d restituire in una versione compatibile con il chiamante originale toSend = Message.CreateMessage(clientMsgVersion, value.Headers.Action, value.GetReaderAtBodyContents()); } } return(toSend); }
public static AdwsFault ConstructFault(Message response) { AdwsFault adwsFault; MessageBuffer buffer = AdwsMessage.MessageToBuffer(response); MessageFault messageFault = MessageFault.CreateFault(AdwsMessage.BufferToMessage(buffer), 0x500000); object obj = null; if (messageFault.HasDetail) { try { string str = string.Concat(messageFault.Code.SubCode.Namespace, ":", messageFault.Code.SubCode.Name); Type item = (Type)AdwsFaultUtil._faultSubCodeType[str]; if (item != null) { XmlReader readerAtDetailContents = messageFault.GetReaderAtDetailContents(); XmlSerializer xmlSerializer = new XmlSerializer(item); obj = xmlSerializer.Deserialize(readerAtDetailContents); } } catch (Exception exception) { } } if (obj == null) { adwsFault = new AdwsFault(messageFault); } else { adwsFault = new AdwsFault(messageFault, obj); } return(adwsFault); }
public void OnPremiseResponseReceiver_ReceiveResponse_FaultMessage() { MockDispatcher dispatcher = new MockDispatcher(); AzureResponseReceiver receiver = new AzureResponseReceiver(dispatcher); Message emptyMessage = Message.CreateMessage(MessageVersion.Default, string.Empty); MessageFault fault = MessageFault.CreateFault(FaultCode.CreateReceiverFaultCode("Error", Constant.HpcHeaderNS), string.Empty); DispatchData data = new DispatchData("1", 0, "1") { BrokerQueueItem = new BrokerQueueItem(null, emptyMessage, null), Client = new MockClient() { Response = Message.CreateMessage(MessageVersion.Default, fault, string.Empty) } }; receiver.ReceiveResponse(data); Assert.AreEqual(data.Exception, null, "Exception is not expected to happen in ReceiveResponse method."); Assert.AreEqual(data.ReplyMessage.IsFault, true, "Expected to receive fault message ReceiveResponse method."); }
void ThrowFaultException(Message message) { string action = message.Headers.Action; MessageFault fault = MessageFault.CreateFault(message, (int)_bindingElement.MaxReceivedMessageSize); throw new FaultException(fault); }
/// <summary> /// Gets the data from specified <see cref="Message"/> object. /// </summary> /// <typeparam name="T">Type of returned object with data.</typeparam> /// <param name="data">The <see cref="Message"/> with data.</param> /// <returns>Object with data.</returns> public static T GetData <T>(Message data) { RoboFramework.Tools.RandomLogHelper.GetLog().Debug("SynchronizationHelper::T GetData<T>(Message data)"); using (data) { if (data == null) { return(default(T)); } if (data.IsFault == true) { MessageFault fault = MessageFault.CreateFault(data, 500000); if (fault.HasDetail) { System.ServiceModel.ExceptionDetail excDet = fault.GetDetail <System.ServiceModel.ExceptionDetail>(); Type excType = String.IsNullOrEmpty(excDet.Type) ? null : Type.GetType(excDet.Type); Exception e = (excType == null) ? new Exception() : (Exception)Activator.CreateInstance(excType); FieldInfo innerExceptionField = typeof(Exception).GetField("_innerException", BindingFlags.NonPublic | BindingFlags.Instance); FieldInfo messageField = typeof(Exception).GetField("_message", BindingFlags.NonPublic | BindingFlags.Instance); FieldInfo stackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.NonPublic | BindingFlags.Instance); innerExceptionField.SetValue(e, excDet.InnerException); messageField.SetValue(e, excDet.Message); stackTraceField.SetValue(e, excDet.StackTrace); throw e; } } return(data.GetBody <T>()); } }
public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { if (reply.IsFault || IsHttpInternalErrorFault(reply)) { ExceptionFault fault = null; var mf = MessageFault.CreateFault(reply, int.MaxValue); try { if (mf.HasDetail && mf.Reason.ToString() == "UnhandledException") { var detail = mf.GetDetail <ExceptionFault>(); fault = detail; } } #pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body catch #pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body { // do nothing } if (fault != null) { fault.ReThrow(); } else { var operation = _runtime.ClientOperations.FirstOrDefault(p => p.Action == (string)correlationState); var faultTypes = _contract.Operations.Where(p => operation == null || p.Name == operation.Name).SelectMany(p => p.Faults.Select(x => x.DetailType)).Distinct().ToArray(); var ex = FaultException.CreateFault(mf, reply.Headers.Action, faultTypes); ExceptionDispatchInfo.Capture(ex).Throw(); } } }
private XmlElement Complete(X509Certificate2 sessionCert, RequestSecurityTokenResponse response) { //we expect SignChallenge, which we need to return as SignChallengeResponse using the body cert/key. if (response.RequestSecurityTokenResponse1.SignChallenge == null) { throw new InvalidOperationException("eHealth WS-Trust service didn't return sign challenge response"); } response.RequestSecurityTokenResponse1.SignChallengeResponse = response.RequestSecurityTokenResponse1.SignChallenge; response.RequestSecurityTokenResponse1.SignChallenge = null; //create a secondary channel to send the challenge ChannelFactory <IWsTrustPortFixed> channelFactory = new ChannelFactory <IWsTrustPortFixed>(base.Endpoint.Binding, base.Endpoint.Address); channelFactory.Credentials.ClientCertificate.Certificate = sessionCert; IWsTrustPortFixed secondary = channelFactory.CreateChannel(); //send the (signed) Challenge, get the reponse as message to not break the internal signature Message responseMsg = secondary.Challenge(response); if (responseMsg.IsFault) { throw new FaultException(MessageFault.CreateFault(responseMsg, 10240), responseMsg.Headers.Action); } var responseBody = new XmlDocument(); responseBody.PreserveWhitespace = true; responseBody.Load(responseMsg.GetReaderAtBodyContents()); //better to check if correcty wrapped, but for now we do not care. return((XmlElement)responseBody.GetElementsByTagName("Assertion", "urn:oasis:names:tc:SAML:1.0:assertion")[0]); }
/// <summary> /// Factory used to create the expected <see cref="MessageFault"/> to be used when returning this fault type. /// </summary> /// <param name="fault">The <see cref="SlaViolationFault"/> to create a <see cref="MessageFault"/> from.</param> /// <returns>The appropriate <see cref="MessageFault"/> for the supplied <see cref="SlaViolationFault"/>.</returns> public static MessageFault CreateStandardFault(SlaViolationFault fault) { var faultCode = CreateStandardCode(); var faultReason = CreateStandardReason(); return(MessageFault.CreateFault(faultCode, faultReason, fault)); }
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); } }
private void ProvideFaultOfLastResort(Exception error, ref ErrorHandlerFaultInfo faultInfo) { if (faultInfo.Fault == null) { FaultCode code = new FaultCode(FaultCodeConstants.Codes.InternalServiceFault, FaultCodeConstants.Namespaces.NetDispatch); code = FaultCode.CreateReceiverFaultCode(code); string action = FaultCodeConstants.Actions.NetDispatcher; MessageFault fault; if (_debug) { faultInfo.DefaultFaultAction = action; fault = MessageFault.CreateFault(code, new FaultReason(error.Message), new ExceptionDetail(error)); } else { string reason = _isOnServer ? SRServiceModel.SFxInternalServerError : SRServiceModel.SFxInternalCallbackError; fault = MessageFault.CreateFault(code, new FaultReason(reason)); } faultInfo.IsConsideredUnhandled = true; faultInfo.Fault = Message.CreateMessage(_messageVersion, fault, action); } //if this is an InternalServiceFault coming from another service dispatcher we should treat it as unhandled so that the channels are cleaned up else if (error != null) { FaultException e = error as FaultException; if (e != null && e.Fault != null && e.Fault.Code != null && e.Fault.Code.SubCode != null && string.Compare(e.Fault.Code.SubCode.Namespace, FaultCodeConstants.Namespaces.NetDispatch, StringComparison.Ordinal) == 0 && string.Compare(e.Fault.Code.SubCode.Name, FaultCodeConstants.Codes.InternalServiceFault, StringComparison.Ordinal) == 0) { faultInfo.IsConsideredUnhandled = true; } } }
private MessageFault BuildFault(Exception error) { ServiceExceptionDetail exceptionDetail = new ServiceExceptionDetail(error); FaultCode code = FaultCode.CreateReceiverFaultCode(ServiceExceptionDetail.FaultSubCodeName, ServiceExceptionDetail.FaultSubCodeNamespace); return(MessageFault.CreateFault(code, new FaultReason(error.Message), exceptionDetail)); }
public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { ColorConsole.WriteLine(ConsoleColor.Cyan, "{0}.{1}", this.GetType().Name, ReflectionUtil.GetMethodSignature(MethodBase.GetCurrentMethod())); MessageFault messageFault = MessageFault.CreateFault(new FaultCode("FaultCode"), new FaultReason(error.Message)); fault = Message.CreateMessage(version, messageFault, "FaultAction"); }
public CoreWCF.Channels.Message Untyped_MethodReturns(CoreWCF.Channels.Message msgIn) { MessageVersion mv = MessageVersion.Soap11; if (null != msgIn) { string faultString = GetTestStrFromMsg(msgIn); switch (faultString) { case VarSomeFault: return(Message.CreateMessage(mv, MessageFault.CreateFault(new FaultCode("Sender"), new FaultReason("Unspecified ServiceModel Fault"), (object)new ServiceContract.SomeFault(123456789, "SomeFault"), new System.Runtime.Serialization.DataContractSerializer(typeof(ServiceContract.SomeFault)), "", ""), "http://tempuri.org/ITestDataContractFault/Untyped_MethodReturnsSomeFaultFault")); case VarOuterFault: ServiceContract.SomeFault sf = new ServiceContract.SomeFault(123456789, "SomeFault as innerfault"); ServiceContract.OuterFault of = new ServiceContract.OuterFault { InnerFault = sf }; return(Message.CreateMessage(mv, MessageFault.CreateFault(new FaultCode("Sender"), new FaultReason("Unspecified ServiceModel Fault"), (object)of, new System.Runtime.Serialization.DataContractSerializer(typeof(ServiceContract.OuterFault)), "", ""), "http://tempuri.org/ITestDataContractFault/Untyped_MethodReturnsOuterFaultFault")); case VarComplexFault: ServiceContract.ComplexFault cf = GetComplexFault(); return(Message.CreateMessage(mv, MessageFault.CreateFault(new FaultCode("Sender"), new FaultReason("Unspecified ServiceModel Fault"), (object)cf, new System.Runtime.Serialization.DataContractSerializer(typeof(ServiceContract.ComplexFault)), "", ""), "http://tempuri.org/ITestDataContractFault/Untyped_MethodReturnsComplexFaultFault")); default: throw new ApplicationException("Unknown value of FaultString specified: " + faultString); } } return(Message.CreateMessage(mv, MessageFault.CreateFault(new FaultCode("Sender"), new FaultReason("Unspecified ServiceModel Fault"), "unspecified", new System.Runtime.Serialization.DataContractSerializer(typeof(string)), "", ""), "http://www.w3.org/2005/08/addressing/fault")); }