//Can only be called inside a service public static void PromoteException(Exception error,MessageVersion version,ref Message fault) { StackFrame frame = new StackFrame(1); Type serviceType = frame.GetMethod().ReflectedType; PromoteException(serviceType,error,version,ref fault); }
protected virtual Message GetJsonFaultMessage(MessageVersion version, Exception error) { BaseFault detail = null; var knownTypes = new List<Type>(); string faultType = error.GetType().Name; //default if ((error is FaultException) && (error.GetType().GetProperty("Detail") != null)) { detail = (error.GetType().GetProperty("Detail").GetGetMethod().Invoke( error, null) as BaseFault); knownTypes.Add(detail.GetType()); faultType = detail.GetType().Name; } var jsonFault = new JsonFault { Message = error.Message, Detail = detail, FaultType = faultType }; var faultMessage = Message.CreateMessage(version, "", jsonFault, new DataContractJsonSerializer(jsonFault.GetType(), knownTypes)); return faultMessage; }
private IChannelFactory <IRequestSessionChannel> CreateChannelFactory(bool useSslStreamSecurity, bool includeExceptionDetails, DnsEndpointIdentity endpointIdentity) { string str; int num = 0; CustomBinding customBinding = SbmpProtocolDefaults.CreateBinding(false, false, 2147483647, useSslStreamSecurity, endpointIdentity); DuplexRequestBindingElement duplexRequestBindingElement = new DuplexRequestBindingElement() { IncludeExceptionDetails = includeExceptionDetails, ClientMode = this.clientMode }; DuplexRequestBindingElement duplexRequestBindingElement1 = duplexRequestBindingElement; int num1 = num; num = num1 + 1; customBinding.Elements.Insert(num1, duplexRequestBindingElement1); BindingParameterCollection bindingParameterCollection = new BindingParameterCollection(); if (useSslStreamSecurity) { ClientCredentials clientCredential = new ClientCredentials(); clientCredential.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.Custom; clientCredential.ServiceCertificate.Authentication.CustomCertificateValidator = RetriableCertificateValidator.Instance; if (SoapProtocolDefaults.IsAvailableClientCertificateThumbprint(out str)) { clientCredential.ClientCertificate.SetCertificate(StoreLocation.LocalMachine, StoreName.My, X509FindType.FindByThumbprint, str); } bindingParameterCollection.Add(clientCredential); } this.MessageVersion = customBinding.MessageVersion; return(customBinding.BuildChannelFactory <IRequestSessionChannel>(bindingParameterCollection)); }
public System.ServiceModel.Channels.Message SerializeReply(System.ServiceModel.Channels.MessageVersion messageVersion, object[] parameters, object result) { Message returnMessage = null; if (_compression && result != null) { XmlSerializer serializer = new XmlSerializer(result.GetType()); using (MemoryStream ms = new MemoryStream()) { serializer.Serialize(ms, result); // Compress MemoryStream data and create message based on messageversion and action returnMessage = Message.CreateMessage(messageVersion, _replyAction, Zip(ms.ToArray())); } } else { // Used defualt serialization returnMessage = _baseFormater.SerializeReply(messageVersion, parameters, result); } return(returnMessage); }
public void ProvideFault(Exception error, c.MessageVersion version, ref c.Message fault) { if (error is FaultException) { return; } }
void IErrorHandler.ProvideFault(Exception error, MessageVersion version, ref Message fault) { this.ErrorGuid = Guid.NewGuid(); FaultException<ExceptionDetail> faultException = new FaultException<ExceptionDetail>(new ExceptionDetail(error) { Message = this.ErrorGuid.ToString() }, new FaultReason("ServiceError")); MessageFault messageFault = faultException.CreateMessageFault(); fault = Message.CreateMessage(version, messageFault, faultException.Action); }
//- @ProvideFault -// public virtual void ProvideFault(Exception error, MessageVersion version, ref Message fault) { fault.Properties[HttpResponseMessageProperty.Name] = new HttpResponseMessageProperty { StatusCode = HttpStatusCode.OK }; }
public System.ServiceModel.Channels.Message SerializeReply(System.ServiceModel.Channels.MessageVersion messageVersion, object[] parameters, object result) { Message returnMessage = null; PerformanceMonitorHelper.GetDefaultMonitor().WriteExecutionDuration("SerializeReply", () => { //返回值总是Raw格式的 string jsonResult = string.Empty; if (result is string) { if (this._AtlasEnabled) { //asp.net ajax 返回值格式 Dictionary <string, object> returnDict = new Dictionary <string, object>(); returnDict.Add("d", result); jsonResult = JSONSerializerExecute.Serialize(returnDict); } else { jsonResult = result.ToString(); } } else { jsonResult = JSONSerializerExecute.SerializeWithType(result); } returnMessage = WcfUtils.CreateJsonFormatReplyMessage(messageVersion, this._OperationDesc.Messages[1].Action, jsonResult); }); return(returnMessage); }
public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { bool includeDetails = IncludeExceptionDetails(); object msgId = null; if (OperationContext.Current.IncomingMessageProperties.ContainsKey(DispatcherUtils.MessageIdKey)) msgId = OperationContext.Current.IncomingMessageProperties[DispatcherUtils.MessageIdKey]; var jsonRpcError = error as JsonRpcException; if (jsonRpcError != null) fault = DispatcherUtils.CreateErrorMessage(version, msgId, jsonRpcError); else { // TODO: extract exception details from FaultException object additionalData; var faultException = error as FaultException; if (faultException != null && faultException.GetType().IsGenericType) { additionalData = faultException.GetType().GetProperty("Detail").GetValue(faultException, null); } else { additionalData = error; } // TODO: check error type and set appropriate error code fault = DispatcherUtils.CreateErrorMessage(version, msgId, (int)JsonRpcErrorCodes.ServerError, error.Message, additionalData); } }
/// <summary cref="IClientMessageFormatter.SerializeRequest" /> public System.ServiceModel.Channels.Message SerializeRequest(System.ServiceModel.Channels.MessageVersion messageVersion, object[] parameters) { Message message = m_clientFormatter.SerializeRequest(messageVersion, parameters); message.Properties.Add(MessageProperties.RequestBody, parameters[0]); return(message); }
internal ChannelHandler(MessageVersion messageVersion, IChannelBinder binder, ServiceChannel channel) { ClientRuntime clientRuntime = channel.ClientRuntime; this.messageVersion = messageVersion; this.isManualAddressing = clientRuntime.ManualAddressing; this.binder = binder; this.channel = channel; this.isConcurrent = true; this.duplexBinder = binder as DuplexChannelBinder; this.hasSession = binder.HasSession; this.isCallback = true; DispatchRuntime dispatchRuntime = clientRuntime.DispatchRuntime; if (dispatchRuntime == null) { this.receiver = new ErrorHandlingReceiver(binder, null); } else { this.receiver = new ErrorHandlingReceiver(binder, dispatchRuntime.ChannelDispatcher); } this.requestInfo = new RequestInfo(this); }
public static CreateSequenceInfo ReadMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion, ISecureConversationSession securitySession, Message message, MessageHeaders headers) { CreateSequenceInfo info; if (message.IsEmpty) { string reason = System.ServiceModel.SR.GetString("NonEmptyWsrmMessageIsEmpty", new object[] { WsrmIndex.GetCreateSequenceActionString(reliableMessagingVersion) }); Message faultReply = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, reason); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(faultReply, reason, new ProtocolException(reason))); } using (XmlDictionaryReader reader = message.GetReaderAtBodyContents()) { info = CreateSequence.Create(messageVersion, reliableMessagingVersion, securitySession, reader); message.ReadFromBodyContentsToEnd(reader); } info.SetMessageId(messageVersion, headers); info.SetReplyTo(messageVersion, headers); if (info.AcksTo.Uri != info.ReplyTo.Uri) { string str2 = System.ServiceModel.SR.GetString("CSRefusedAcksToMustEqualReplyTo"); Message message3 = WsrmUtilities.CreateCSRefusedProtocolFault(messageVersion, reliableMessagingVersion, str2); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(WsrmMessageInfo.CreateInternalFaultException(message3, str2, new ProtocolException(str2))); } info.to = message.Headers.To; if ((info.to == null) && (messageVersion.Addressing == AddressingVersion.WSAddressing10)) { info.to = messageVersion.Addressing.AnonymousUri; } return info; }
protected override IChannelFactory<IRequestReplyService> SelectChannelFactory(out MessageVersion messageVersion) { base.interoperating = false; EndpointIdentity identity = base.to.Identity; if (identity != null) { string claimType = identity.IdentityClaim.ClaimType; if ((claimType != ClaimTypes.Spn) && (claimType != ClaimTypes.Upn)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CreateChannelFailureException(Microsoft.Transactions.SR.GetString("InvalidTrustIdentityType", new object[] { claimType }))); } } string scheme = base.to.Uri.Scheme; if (string.Compare(scheme, Uri.UriSchemeNetPipe, StringComparison.OrdinalIgnoreCase) == 0) { messageVersion = base.coordinationService.NamedPipeActivationBinding.MessageVersion; return base.coordinationService.NamedPipeActivationChannelFactory; } if (!base.coordinationService.Config.RemoteClientsEnabled || (string.Compare(scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase) != 0)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CreateChannelFailureException(Microsoft.Transactions.SR.GetString("InvalidSchemeWithTrustIdentity", new object[] { scheme }))); } messageVersion = base.coordinationService.WindowsActivationBinding.MessageVersion; return base.coordinationService.WindowsActivationChannelFactory; }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { var faultEx = new FaultException <ApiFault>(new ApiFault(error.Message), new FaultReason(error.Message)); fault = Message.CreateMessage(version, faultEx.CreateMessageFault(), "error"); fault.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(WebContentFormat.Xml)); WebOperationContext.Current.OutgoingResponse.StatusDescription = error.Message; //WebOperationContext.Current.OutgoingResponse.SuppressEntityBody = true; // specal hack to prevent forms auth redirection var code = error is ApiException ? ((ApiException)error).StatusCode : System.Net.HttpStatusCode.InternalServerError; if (error is System.Runtime.Serialization.SerializationException) { code = HttpStatusCode.BadRequest; } WebOperationContext.Current.OutgoingResponse.StatusCode = code == HttpStatusCode.Unauthorized ? HttpStatusCode.Unauthorized : code; if (error is ApiException) { WebOperationContext.Current.OutgoingResponse.Headers["error_id"] = ((ApiException)error).ErrorId; } }
internal CustomTextMessageEncoderFactory(string mediaType, string charSet, MessageVersion version) { _version = version; _mediaType = mediaType; _charSet = charSet; _encoder = new CustomTextMessageEncoder(this); }
internal ErrorBehavior(ChannelDispatcher channelDispatcher) { this.handlers = EmptyArray<IErrorHandler>.ToArray(channelDispatcher.ErrorHandlers); this.debug = channelDispatcher.IncludeExceptionDetailInFaults; this.isOnServer = channelDispatcher.IsOnServer; this.messageVersion = channelDispatcher.MessageVersion; }
protected TransportChannelFactory(TransportBindingElement bindingElement, BindingContext context, System.ServiceModel.Channels.MessageEncoderFactory defaultMessageEncoderFactory) : base(context.Binding) { this.manualAddressing = bindingElement.ManualAddressing; this.maxBufferPoolSize = bindingElement.MaxBufferPoolSize; this.maxReceivedMessageSize = bindingElement.MaxReceivedMessageSize; Collection <MessageEncodingBindingElement> messageEncodingBindingElements = context.BindingParameters.FindAll <MessageEncodingBindingElement>(); if (messageEncodingBindingElements.Count > 1) { throw Microsoft.ServiceBus.Diagnostics.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(Microsoft.ServiceBus.SR.GetString(Resources.MultipleMebesInParameters, new object[0]))); } if (messageEncodingBindingElements.Count != 1) { this.messageEncoderFactory = defaultMessageEncoderFactory; } else { this.messageEncoderFactory = messageEncodingBindingElements[0].CreateMessageEncoderFactory(); context.BindingParameters.Remove <MessageEncodingBindingElement>(); } if (this.messageEncoderFactory == null) { this.messageVersion = System.ServiceModel.Channels.MessageVersion.None; return; } this.messageVersion = this.messageEncoderFactory.MessageVersion; }
public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { Contract.Requires<NullReferenceException>(error != null); FaultCode code = FaultCode.CreateSenderFaultCode(error.GetType().Name, FaultNs); fault = Message.CreateMessage(version, code, error.Message, null); if (this.Context != null) { var se = error as ServiceException; if (se != null) { Context.OutgoingResponse.StatusCode = ((ServiceException)error).StatusCode; } var sb = new StringBuilder(); for (int i = 0; i < error.Message.Length; i++) { var ch = (char)('\x00ff' & error.Message[i]); if (((ch <= '\x001f') && (ch != '\t')) || (ch == '\x007f')) { // Specified value has invalid Control characters. // See HttpListenerResponse.StatusDescription implementation. } else { sb.Append(ch); } } Context.OutgoingResponse.StatusDescription = sb.ToString(); Context.OutgoingResponse.SuppressEntityBody = false; } }
public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result) { JObject json = new JObject(); json[JsonRpcConstants.ErrorKey] = null; json[JsonRpcConstants.ResultKey] = JToken.FromObject(result); return JsonRpcHelpers.SerializeMessage(json, null); }
public Message CreateMessage(MessageVersion messageVersion, ReliableMessagingVersion reliableMessagingVersion) { this.SetReliableMessagingVersion(reliableMessagingVersion); string faultActionString = WsrmIndex.GetFaultActionString(messageVersion.Addressing, reliableMessagingVersion); if (messageVersion.Envelope == EnvelopeVersion.Soap11) { this.code = this.Get11Code(this.code, this.subcode); } else { if (messageVersion.Envelope != EnvelopeVersion.Soap12) { throw Fx.AssertAndThrow("Unsupported MessageVersion."); } if (this.code.SubCode == null) { FaultCode subCode = new FaultCode(this.subcode, WsrmIndex.GetNamespaceString(reliableMessagingVersion)); this.code = new FaultCode(this.code.Name, this.code.Namespace, subCode); } this.hasDetail = this.Get12HasDetail(); } Message message = Message.CreateMessage(messageVersion, this, faultActionString); this.OnFaultMessageCreated(messageVersion, message); return message; }
/// <summary> /// Serializes a reply message from a specified message version, array of parameters, and a return value. /// </summary> /// <param name="messageVersion">The SOAP message version.</param> /// <param name="parameters">The out parameters.</param> /// <param name="result">The return value.</param> /// <returns>he serialized reply message.</returns> Message IDispatchMessageFormatter.SerializeReply( MessageVersion messageVersion, object[] parameters, object result) { if (parameters == null) { throw new ArgumentNullException("parameters"); } if (messageVersion != MessageVersion.None) { throw new NotSupportedException( string.Format( CultureInfo.CurrentCulture, SR.HttpMessageFormatterMessageVersion, this.GetType())); } HttpResponseMessage response = this.GetDefaultResponse(); if (response == null) { throw new InvalidOperationException( string.Format( CultureInfo.CurrentCulture, SR.HttpMessageFormatterNullResponse, this.GetType())); } this.SerializeReply(parameters, result, response); return response.ToMessage(); }
/// <summary> /// Serializes a reply message from a specified message version, array of parameters, and a return value. /// </summary> /// <param name="messageVersion">The SOAP message version.</param> /// <param name="parameters">The out parameters.</param> /// <param name="result">The return value.</param> /// <returns>The serialized reply message.</returns> public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result) { // Instantiate a new domain data service and ask it to process the incoming request. // We already have the result of the invocation handy, so we can simply pass it to // the IDSP implementation for domain data service. return this.serviceFactory.CreateService(result).ProcessRequestForMessage(new MemoryStream()); }
public RelayedOnewayChannelListener(BindingContext context, RelayedOnewayTransportBindingElement transportBindingElement) : base(context.Binding) { this.nameSettings = context.BindingParameters.Find <Microsoft.ServiceBus.NameSettings>(); if (this.nameSettings == null) { this.nameSettings = new Microsoft.ServiceBus.NameSettings(); this.nameSettings.ServiceSettings.ListenerType = ListenerType.Unicast; } this.scheme = context.Binding.Scheme; this.messageVersion = context.Binding.MessageVersion; switch (context.ListenUriMode) { case ListenUriMode.Explicit: { this.SetUri(context.ListenUriBaseAddress, context.ListenUriRelativeAddress); break; } case ListenUriMode.Unique: { this.SetUniqueUri(context.ListenUriBaseAddress, context.ListenUriRelativeAddress); break; } } this.channel = new RelayedOnewayChannelListener.RelayedOnewayInputChannel(this, new EndpointAddress(this.Uri, new AddressHeader[0])); base.Acceptor = new Microsoft.ServiceBus.Channels.InputChannelAcceptor(this, () => this.GetPendingException()); this.ChannelAcceptor.EnqueueAndDispatch(this.channel, new Action(this.OnChannelDequeued)); this.connection = RelayedOnewayManager.RegisterListener(context, transportBindingElement, this); }
public BufferedHeader(MessageVersion version, XmlBuffer buffer, XmlDictionaryReader reader, XmlAttributeHolder[] envelopeAttributes, XmlAttributeHolder[] headerAttributes) { this.streamed = true; this.buffer = buffer; this.version = version; MessageHeader.GetHeaderAttributes(reader, version, out this.actor, out this.mustUnderstand, out this.relay, out this.isRefParam); this.name = reader.LocalName; this.ns = reader.NamespaceURI; this.bufferIndex = buffer.SectionCount; XmlDictionaryWriter writer = buffer.OpenSection(reader.Quotas); writer.WriteStartElement("Envelope"); if (envelopeAttributes != null) { XmlAttributeHolder.WriteAttributes(envelopeAttributes, writer); } writer.WriteStartElement("Header"); if (headerAttributes != null) { XmlAttributeHolder.WriteAttributes(headerAttributes, writer); } writer.WriteNode(reader, false); writer.WriteEndElement(); writer.WriteEndElement(); buffer.CloseSection(); }
public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { FaultException faultException; var logger = LogManager.GetCurrentClassLogger(); if (error != null && error is ObjectValidationException) { faultException = new FaultException<ValidationFault>(new ValidationFault(((ObjectValidationException)error).ValidationErrors.Select(item => new ValidationError { ErrorMessage = item.ErrorMessage, ObjectName = item.ObjectName, PropertyName = item.PropertyName })), new FaultReason("Validation error")); logger.Error(error, "Validation error in GlobalError filter"); } else { faultException = new FaultException<InternalServiceFault>(new InternalServiceFault(error, string.Format("Exception caught at GlobalErrorHandler{0}Method: {1}{2}Message:{3}", Environment.NewLine, error.TargetSite.Name, Environment.NewLine, error.Message))); logger.Error(error, "Generic internal error in GlobalError filter"); } // Shield the unknown exception //FaultException faultException = new FaultException<SimpleErrorFault>(new SimpleErrorFault(), new FaultReason("Server error encountered. All details have been logged.")); //new FaultException("Server error encountered. All details have been logged."); MessageFault messageFault = faultException.CreateMessageFault(); fault = Message.CreateMessage(version, messageFault, faultException.Action); }
public Message SerializeRequest(MessageVersion messageVersion, object[] parameters) { MemoryStream outStream = new MemoryStream(); StreamWriter writer = new StreamWriter(outStream); writer.WriteLine("--" + Boundary); writer.WriteLine("Content-Disposition: form-data; name=\"torrent_file\"; filename=\"foo.torrent\""); writer.WriteLine("Content-Type: "); writer.WriteLine(); writer.Flush(); (parameters[0] as Stream).CopyTo(outStream); writer.WriteLine(); writer.WriteLine("--" + Boundary + "--"); writer.Flush(); outStream.Seek(0, SeekOrigin.Begin); parameters[0] = outStream; Message request = this.originalFormatter.SerializeRequest(messageVersion, parameters); if (!request.Properties.ContainsKey(HttpRequestMessageProperty.Name)) { request.Properties[HttpRequestMessageProperty.Name] = new HttpRequestMessageProperty(); } HttpRequestMessageProperty http = request.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty; http.Headers.Set(HttpRequestHeader.ContentType, "multipart/form-data; boundary=" + Boundary); http.Headers.Remove(HttpRequestHeader.Expect); return request; }
/// <summary> /// Enables the creation of a custom System.ServiceModel.FaultException{TDetail} /// that is returned from an exception in the course of a service method. /// </summary> /// <param name="error">The System.Exception object thrown in the course of the service operation.</param> /// <param name="version">The SOAP version of the message.</param> /// <param name="fault">The System.ServiceModel.Channels.Message object that is returned to the client, or service in duplex case</param> public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { if (error is FaultException <ApplicationServiceError> ) { MessageFault messageFault = ((FaultException <ApplicationServiceError>)error).CreateMessageFault(); //propagate FaultException fault = Message.CreateMessage(version, messageFault, ((FaultException <ApplicationServiceError>)error).Action); } else { //create service error ApplicationServiceError defaultError = new ApplicationServiceError() { ErrorMessage = Resources.Messages.message_DefaultErrorMessage }; //Create fault exception and message fault FaultException <ApplicationServiceError> defaultFaultException = new FaultException <ApplicationServiceError>(defaultError); MessageFault defaultMessageFault = defaultFaultException.CreateMessageFault(); //propagate FaultException fault = Message.CreateMessage(version, defaultMessageFault, defaultFaultException.Action); } }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { // Tell WCF to use JSON encoding rather than default XML var webBodyFormatProperty = new WebBodyFormatMessageProperty(WebContentFormat.Json); var responseProperty = new HttpResponseMessageProperty(); responseProperty.Headers.Add(HttpResponseHeader.ContentType, "application/json"); if (error is FaultException) { // Extract the FaultContract object from the exception object. var detail = error.GetType().GetProperty("Detail").GetGetMethod().Invoke(error, null); // Return custom error http response. responseProperty.StatusCode = System.Net.HttpStatusCode.Unauthorized; // Create a fault message containing our FaultContract object fault = Message.CreateMessage(version, "", detail, new DataContractJsonSerializer(detail.GetType())); fault.Properties.Add(WebBodyFormatMessageProperty.Name, webBodyFormatProperty); fault.Properties.Add(HttpResponseMessageProperty.Name, responseProperty); } else { // Return custom error http response. responseProperty.StatusCode = System.Net.HttpStatusCode.InternalServerError; var detail = error.Message; fault = Message.CreateMessage(version, "", detail, new DataContractJsonSerializer(typeof(string))); fault.Properties.Add(WebBodyFormatMessageProperty.Name, webBodyFormatProperty); fault.Properties.Add(HttpResponseMessageProperty.Name, responseProperty); } }
public void ProvideFault(Exception exception, MessageVersion version, ref Message fault) { if (exception.GetType() == typeof(HttpException)) { var httpException = (HttpException)exception; var inResponse = WebOperationContext.Current.IncomingRequest; var webGetAttribute = GetCurrentAttribute(inResponse); if(webGetAttribute == null) { throw new RestException(); } var currentResponseFormat = webGetAttribute.ResponseFormat; var restErrorMessage = new RestErrorMessage(httpException.Data, httpException.GetHttpCode(), httpException.ErrorCode); fault = CreateMessage(restErrorMessage, version, currentResponseFormat); fault.Properties.Add(WebBodyFormatMessageProperty.Name, GetBodyFormat(currentResponseFormat)); var outResponse = WebOperationContext.Current.OutgoingResponse; outResponse.StatusCode = (HttpStatusCode)httpException.GetHttpCode(); outResponse.ContentType = string.Format("application/{0}", currentResponseFormat); } else { throw new RestException(); } }
public void ProvideFault(Exception error, MessageVersion version,ref Message fault) { fault = this.GetJsonFaultMessage(version, error); this.ApplyJsonSettings(ref fault); this.ApplyHttpResponseSettings(ref fault, System.Net.HttpStatusCode.BadRequest, "status desrckslndf"); }
internal Message ProvideFault(MessageVersion messageVersion) { WSAddressing10ProblemHeaderQNameFault fault = new WSAddressing10ProblemHeaderQNameFault(this); Message message = Message.CreateMessage(messageVersion, fault, messageVersion.Addressing.FaultAction); fault.AddHeaders(message.Headers); return message; }
/// <summary> /// Enables the creation of a custom System.ServiceModel.FaultException{TDetail} /// that is returned from an exception in the course of a service method. /// </summary> /// <param name="error">The System.Exception object thrown in the course of the service operation.</param> /// <param name="version">The SOAP version of the message.</param> /// <param name="fault"> /// The System.ServiceModel.Channels.Message object that is returned to the client, or service in /// duplex case /// </param> public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { if (error is FaultException<ApplicationServiceError>) { var messageFault = ((FaultException<ApplicationServiceError>) error).CreateMessageFault(); //propagate FaultException fault = Message.CreateMessage( version, messageFault, ((FaultException<ApplicationServiceError>) error).Action); } else { //create service error var defaultError = new ApplicationServiceError() { ErrorMessage = Messages.message_DefaultErrorMessage }; //Create fault exception and message fault var defaultFaultException = new FaultException<ApplicationServiceError>(defaultError); var defaultMessageFault = defaultFaultException.CreateMessageFault(); //propagate FaultException fault = Message.CreateMessage(version, defaultMessageFault, defaultFaultException.Action); } }
public IssuedTokensHeader(XmlReader xmlReader, MessageVersion version, SecurityStandardsManager standardsManager) : base() { if (xmlReader == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xmlReader"); } if (standardsManager == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("standardsManager")); } this.standardsManager = standardsManager; XmlDictionaryReader reader = XmlDictionaryReader.CreateDictionaryReader(xmlReader); MessageHeader.GetHeaderAttributes(reader, version, out this.actor, out this.mustUnderstand, out this.relay, out this.isRefParam); reader.ReadStartElement(this.Name, this.Namespace); Collection<RequestSecurityTokenResponse> coll = new Collection<RequestSecurityTokenResponse>(); if (this.standardsManager.TrustDriver.IsAtRequestSecurityTokenResponseCollection(reader)) { RequestSecurityTokenResponseCollection rstrColl = this.standardsManager.TrustDriver.CreateRequestSecurityTokenResponseCollection(reader); foreach (RequestSecurityTokenResponse rstr in rstrColl.RstrCollection) { coll.Add(rstr); } } else { RequestSecurityTokenResponse rstr = this.standardsManager.TrustDriver.CreateRequestSecurityTokenResponse(reader); coll.Add(rstr); } this.tokenIssuances = new ReadOnlyCollection<RequestSecurityTokenResponse>(coll); reader.ReadEndElement(); }
public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result) { WebOperationContext currentContext = WebOperationContext.Current; OutgoingWebResponseContext outgoingResponse = null; if (currentContext != null) { outgoingResponse = currentContext.OutgoingResponse; } WebMessageFormat format = this.defaultFormat; if (outgoingResponse != null) { WebMessageFormat? nullableFormat = outgoingResponse.Format; if (nullableFormat.HasValue) { format = nullableFormat.Value; } } if (!this.formatters.ContainsKey(format)) { string operationName = "<null>"; if (OperationContext.Current != null) { MessageProperties messageProperties = OperationContext.Current.IncomingMessageProperties; if (messageProperties.ContainsKey(WebHttpDispatchOperationSelector.HttpOperationNamePropertyName)) { operationName = messageProperties[WebHttpDispatchOperationSelector.HttpOperationNamePropertyName] as string; } } throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.OperationDoesNotSupportFormat, operationName, format.ToString()))); } if (outgoingResponse != null && string.IsNullOrEmpty(outgoingResponse.ContentType)) { string automatedSelectionContentType = outgoingResponse.AutomatedFormatSelectionContentType; if (!string.IsNullOrEmpty(automatedSelectionContentType)) { // Don't set the content-type if it is default xml for backwards compatiabilty if (!string.Equals(automatedSelectionContentType, defaultContentTypes[WebMessageFormat.Xml], StringComparison.OrdinalIgnoreCase)) { outgoingResponse.ContentType = automatedSelectionContentType; } } else { // Don't set the content-type if it is default xml for backwards compatiabilty if (format != WebMessageFormat.Xml) { outgoingResponse.ContentType = defaultContentTypes[format]; } } } Message message = this.formatters[format].SerializeReply(messageVersion, parameters, result); return message; }
/// <summary> /// Enables the creation of a custom <see cref="System.ServiceModel.FaultException"/> /// that is returned from an exception in the course of a service method. /// </summary> /// <param name="error"></param> /// <param name="version"></param> /// <param name="faultMessage"></param> public void ProvideFault(Exception error, MessageVersion version, ref Message faultMessage) { // Gets a serializable Fault object fromn error. Fault fault = Fault.GetFault(error); // Now we make the message by serializing the Fault to JSON. faultMessage = Message.CreateMessage(version, null, fault, new DataContractJsonSerializer(fault.GetType())); // Gotta set HTTP status codes. HttpResponseMessageProperty prop = new HttpResponseMessageProperty() { StatusCode = HttpStatusCode.InternalServerError, // 500 StatusDescription = "An internal server error occurred." // Could use elaboration. }; // Make sure to set the content type. Important for avoiding // certain kinds of encoding-specific XSS attacks. prop.Headers[HttpResponseHeader.ContentType] = "application/json; charset=utf-8"; // Set a few other properties of the Message. faultMessage.Properties.Add(HttpResponseMessageProperty.Name, prop); faultMessage.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(WebContentFormat.Json)); }
protected virtual void OnImportPolicy (XmlElement assertion, MessageVersion messageVersion, MetadataImporter exporter, PolicyConversionContext context) { throw new NotImplementedException (); }
public void ProvideFault(Exception error, MessageVersion version, ref Message fault) { var newEx = new FaultException(string.Format("服务端错误 {0}", error.TargetSite.Name)); MessageFault msgFault = newEx.CreateMessageFault(); fault = Message.CreateMessage(version, msgFault, newEx.Action); }
internal static IListenerBinder GetBinder(IChannelListener listener, MessageVersion messageVersion) { IChannelListener<IInputChannel> listener2 = listener as IChannelListener<IInputChannel>; if (listener2 != null) { return new InputListenerBinder(listener2, messageVersion); } IChannelListener<IInputSessionChannel> listener3 = listener as IChannelListener<IInputSessionChannel>; if (listener3 != null) { return new InputSessionListenerBinder(listener3, messageVersion); } IChannelListener<IReplyChannel> listener4 = listener as IChannelListener<IReplyChannel>; if (listener4 != null) { return new ReplyListenerBinder(listener4, messageVersion); } IChannelListener<IReplySessionChannel> listener5 = listener as IChannelListener<IReplySessionChannel>; if (listener5 != null) { return new ReplySessionListenerBinder(listener5, messageVersion); } IChannelListener<IDuplexChannel> listener6 = listener as IChannelListener<IDuplexChannel>; if (listener6 != null) { return new DuplexListenerBinder(listener6, messageVersion); } IChannelListener<IDuplexSessionChannel> listener7 = listener as IChannelListener<IDuplexSessionChannel>; if (listener7 == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("UnknownListenerType1", new object[] { listener.Uri.AbsoluteUri }))); } return new DuplexSessionListenerBinder(listener7, messageVersion); }
public void ProvideFault( Exception error, MessageVersion version, ref Message fault) { if (error is WebFaultException) return; object responseMessage; HttpStatusCode responseStatusCode; if (error is UserException || error is ClientException) { responseStatusCode = HttpStatusCode.BadRequest; responseMessage = error.Message; } else { responseStatusCode = HttpStatusCode.InternalServerError; responseMessage = "Internal server error occurred (" + error.GetType().Name + "). See RhetosServer.log for more information."; } fault = Message.CreateMessage(version, "", responseMessage, new System.Runtime.Serialization.Json.DataContractJsonSerializer(responseMessage.GetType())); fault.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(WebContentFormat.Json)); fault.Properties.Add(HttpResponseMessageProperty.Name, new HttpResponseMessageProperty {StatusCode = responseStatusCode}); var response = WebOperationContext.Current.OutgoingResponse; response.ContentType = "application/json"; response.StatusCode = responseStatusCode; }
internal static IListenerBinder GetBinder(IChannelListener listener, MessageVersion messageVersion) { IChannelListener<IInputChannel> input = listener as IChannelListener<IInputChannel>; if (input != null) return new InputListenerBinder(input, messageVersion); IChannelListener<IInputSessionChannel> inputSession = listener as IChannelListener<IInputSessionChannel>; if (inputSession != null) return new InputSessionListenerBinder(inputSession, messageVersion); IChannelListener<IReplyChannel> reply = listener as IChannelListener<IReplyChannel>; if (reply != null) return new ReplyListenerBinder(reply, messageVersion); IChannelListener<IReplySessionChannel> replySession = listener as IChannelListener<IReplySessionChannel>; if (replySession != null) return new ReplySessionListenerBinder(replySession, messageVersion); IChannelListener<IDuplexChannel> duplex = listener as IChannelListener<IDuplexChannel>; if (duplex != null) return new DuplexListenerBinder(duplex, messageVersion); IChannelListener<IDuplexSessionChannel> duplexSession = listener as IChannelListener<IDuplexSessionChannel>; if (duplexSession != null) return new DuplexSessionListenerBinder(duplexSession, messageVersion); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.UnknownListenerType1, listener.Uri.AbsoluteUri))); }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { string errName = string.Format("调用 {0} 时异常", OperationContext.Current.IncomingMessageProperties["HttpOperationName"]); WfErrorDTO errorDTO = new WfErrorDTO() { Number = 100, Name = errName, Message = error.Message, Description = error.StackTrace }; string jsonResult = string.Empty; try { jsonResult = JSONSerializerExecute.SerializeWithType(errorDTO); } catch (InvalidOperationException) { errorDTO.Description = string.Empty; jsonResult = JSONSerializerExecute.SerializeWithType(errorDTO); } fault = WcfUtils.CreateJsonFormatReplyMessage(version, null, jsonResult); }
public void ProvideFault(System.Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message message) { var fault = new Fault(); if (error is FaultException) { // extract the our FaultContract object from the exception object. var detail = error.GetType().GetProperty("Detail").GetGetMethod().Invoke(error, null); // create a fault message containing our FaultContract object message = Message.CreateMessage(version, "", detail, new DataContractJsonSerializer(detail.GetType())); // tell WCF to use JSON encoding rather than default XML var wbf = new WebBodyFormatMessageProperty(WebContentFormat.Json); message.Properties.Add(WebBodyFormatMessageProperty.Name, wbf); // return custom error code. var rmp = new HttpResponseMessageProperty(); rmp.StatusCode = System.Net.HttpStatusCode.BadRequest; // put appropraite description here.. rmp.StatusDescription = "See fault object for more information."; message.Properties.Add(HttpResponseMessageProperty.Name, rmp); } else if (error is SerializationException) { fault.Error = error.Message; fault.Error = "Could not decode request: JSON parsing failed"; toJson(fault, ref message); } }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { if (error == null) { return; } ErrorLog.GetDefault(null).Log(new Elmah.Error(error)); }
public SocketConnectionChannelFactory(SocketConnectionBindingElement bindingElement, BindingContext context, bool enableKeepAlive) : base(bindingElement, context, bindingElement.ConnectionPoolSettings.GroupName, bindingElement.ConnectionPoolSettings.IdleTimeout, bindingElement.ConnectionPoolSettings.MaxOutboundConnectionsPerEndpoint) { this.enableKeepAlive = enableKeepAlive; this.connectionElement = bindingElement.ConnectionElement; this.leaseTimeout = bindingElement.ConnectionPoolSettings.LeaseTimeout; this.messageVersion = context.Binding.MessageVersion; this.securityCapabilities = bindingElement.GetProperty <ISecurityCapabilities>(context); }
public DuplexSessionChannel(ChannelManagerBase channelManager, IDuplexSessionChannel innerChannel, System.ServiceModel.Channels.MessageVersion messageVersion, bool enableKeepAlive) : base(channelManager, innerChannel) { this.innerChannel = innerChannel; this.messageVersion = messageVersion; this.enableKeepAlive = enableKeepAlive; this.pingTimer = new IOThreadTimer(SocketConnectionChannelFactory <TChannel> .DuplexSessionChannel.pingCallbackStatic, this, false); this.suppressPing = false; }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { if (!(error is FaultException)) { FaultException FE = new FaultException("We apologize for the inconvenience, an error occurred while processing your request."); MessageFault MF = FE.CreateMessageFault(); fault = Message.CreateMessage(version, MF, null); } }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { MessageResponse messageResponseError = new MessageResponse(error); FaultException <MessageResponse> faultException = new FaultException <MessageResponse>(messageResponseError); MessageFault messageFault = faultException.CreateMessageFault(); fault = Message.CreateMessage(version, messageFault, null); }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { if (error is FaultException) { return; } var er = new FaultException(error.Message, new FaultCode("ServerException")); fault = Message.CreateMessage(version, er.CreateMessageFault(), "Error occured on server"); }
/// <summary> /// If you want to communicate the exception details to the service client /// as proper fault message /// here is the place to do it /// If we want to suppress the communication about the exception, /// set fault to null /// </summary> /// <param name="error"></param> /// <param name="version"></param> /// <param name="fault"></param> public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { var newEx = new FaultException( $"Exception caught at Service Application GlobalErrorHandler{Environment.NewLine}Method: {error.TargetSite.Name}{Environment.NewLine}Message: {error.Message}"); MessageFault msgFault = newEx.CreateMessageFault(); fault = Message.CreateMessage(version, msgFault, newEx.Action); }
/// <summary> /// Provides the error message back to the client through the message provider. /// </summary> /// <param name="error">The current error that has occured.</param> /// <param name="version">The SOAP message version.</param> /// <param name="fault">The communication channel between the client and server, /// sends the message with the error to the client.</param> public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { // Construct the fault message to send to // the client. FaultException faultException = new FaultException(error.Message); MessageFault messageFault = faultException.CreateMessageFault(); fault = System.ServiceModel.Channels.Message.CreateMessage(version, messageFault, faultException.Action); }
/// <summary> /// ProvideFault /// </summary> /// <param name="exception"></param> /// <param name="version"></param> /// <param name="fault"></param> public void ProvideFault(Exception exception, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { //Propogate the exception back to the client. //if (exception is FaultException) // return; //else //{ // FaultException faultException = new FaultException(exception.Message); // MessageFault messageFault = faultException.CreateMessageFault(); // fault = Message.CreateMessage(version, messageFault, faultException.Action); //} }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { if (error is FaultException) { return; } FaultException fe = new FaultException("A General service error has occured"); System.ServiceModel.Channels.MessageFault mf = fe.CreateMessageFault(); fault = Message.CreateMessage(version, mf, null); //throw new NotImplementedException(); }
/// <summary> /// 自定义消息错误处理 /// </summary> /// <param name="error"></param> /// <param name="version"></param> /// <param name="fault"></param> public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { ///全局错误日志记录 //string.Format("ERROR:{0}\r\n引起异常方法:{1}\r\n详细:{2}", // OperationContext.Current.IncomingMessageHeaders.Action.ToString(), // error.TargetSite.Name, error.Message).WriteLog("SystemErrorLog"); var newEx = new FaultException(string.Format("ERROR:{0} ", error.Message)); MessageFault msgFault = newEx.CreateMessageFault(); fault = Message.CreateMessage(version, msgFault, newEx.Action); }
/// <summary> /// If you want to communicate the exception details to the service client /// as proper fault message /// here is the place to do it /// If we want to suppress the communication about the exception, /// set fault to null /// </summary> /// <param name="error"></param> /// <param name="version"></param> /// <param name="fault"></param> public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { FaultException newEx = null; newEx = new FaultException( string.Format("Exception caught at Service Application GlobalErrorHandler{0}Method: {1} {2} Message: {3}", Environment.NewLine, error.TargetSite.Name, Environment.NewLine, error.Message)); MessageFault msgFault = newEx.CreateMessageFault(); fault = Message.CreateMessage(version, msgFault, newEx.Action); }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { if (error is FaultException) { // Let WCF do normal processing } else { // Generate fault message manually including the exception as the fault detail MessageFault messageFault = MessageFault.CreateFault(new FaultCode("Sender"), new FaultReason(error.Message), error, new NetDataContractSerializer()); fault = Message.CreateMessage(version, messageFault, null); } }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { if (fault == null) { if (error is ConfigurationErrorsException) { FaultException <ReceiverFaultDetail> fe = new FaultException <ReceiverFaultDetail>(new ReceiverFaultDetail(error.Message, true), error.Message, FaultCode.CreateReceiverFaultCode(new FaultCode("Configuration"))); MessageFault mf = fe.CreateMessageFault(); fault = Message.CreateMessage(version, mf, fe.Action); } } }
public void ProvideFault(Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { if (error is FaultException) { return; } // Return a general service error message to the client FaultException faultException = new FaultException("A general service error occured"); MessageFault messageFault = faultException.CreateMessageFault(); fault = Message.CreateMessage(version, messageFault, null); }
/// <summary> /// 在异常发生后,异常信息返回前被调用 /// </summary> /// <param name="error">异常</param> /// <param name="version">SOAP版本</param> /// <param name="fault">返回给客户端的错误信息</param> public void ProvideFault(System.Exception error, System.ServiceModel.Channels.MessageVersion version, ref System.ServiceModel.Channels.Message fault) { if (error is System.IO.IOException) { FaultException ex = new FaultException("IErrorHandler - ProvideFault测试"); MessageFault mf = ex.CreateMessageFault(); fault = System.ServiceModel.Channels.Message.CreateMessage(version, mf, ex.Action); // InvalidOperationException error = new InvalidOperationException("An invalid operation has occurred."); // MessageFault mfault = MessageFault.CreateFault(new FaultCode("Server", new FaultCode(String.Format("Server.{0}", error.GetType().Name))), new FaultReason(error.Message), error); // FaultException fe = FaultException.CreateFault(mfault, typeof(InvalidOperationException)); } }
internal ProxyRpc(ServiceChannel channel, ProxyOperationRuntime operation, string action, object[] inputs, TimeSpan timeout) { this.Action = action; this.Activity = null; this.Channel = channel; this.Correlation = EmptyArray.Allocate(operation.Parent.CorrelationCount); this.InputParameters = inputs; this.Operation = operation; this.OutputParameters = null; this.Request = null; this.Reply = null; this.ActivityId = Guid.Empty; this.ReturnValue = null; this.MessageVersion = channel.MessageVersion; this.TimeoutHelper = new System.Runtime.TimeoutHelper(timeout); }
private static bool IsMessageVersionMatch(System.ServiceModel.Channels.MessageVersion a, System.ServiceModel.Channels.MessageVersion b) { if (b == null) { throw FxTrace.Exception.ArgumentNull("b"); } if (a.Addressing == null) { throw FxTrace.Exception.AsError(new InvalidOperationException("MessageVersion.Addressing cannot be null"), null); } if (a.Envelope != b.Envelope) { return(false); } return(true); }