public bool TryCreateException(Message message, MessageFault fault, out Exception exception)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
if (fault == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("fault");
}
bool created = this.OnTryCreateException(message, fault, out exception);
if (created)
{
if (exception == null)
{
string text = SR.Format(SR.FaultConverterDidNotCreateException, this.GetType().Name);
Exception error = new InvalidOperationException(text);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
}
}
else
{
if (exception != null)
{
string text = SR.Format(SR.FaultConverterCreatedException, this.GetType().Name);
Exception error = new InvalidOperationException(text, exception);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(error);
}
}
return created;
}
public XmlRpcMessage(MessageFault fault)
: this()
{
isFault = true;
bodyReader = XmlRpcDataContractSerializationHelper.CreateFaultReader(fault);
bodyReader.MoveToContent();
}
protected FaultException(SerializationInfo info, StreamingContext context) : base(info, context)
{
this.code = this.ReconstructFaultCode(info, "code");
this.reason = this.ReconstructFaultReason(info, "reason");
this.fault = (MessageFault) info.GetValue("messageFault", typeof(MessageFault));
this.action = info.GetString("action");
}
private static LogData CreateLogbookentry(Exception error, MessageFault fault)
{
string typeName, methodName;
string assemblyName = typeName = methodName = "Unknown";
if (error.TargetSite != null)
{
assemblyName = error.TargetSite.Module.Assembly.GetName().Name;
methodName = error.TargetSite.Name;
if (error.TargetSite.DeclaringType != null) typeName = error.TargetSite.DeclaringType.Name;
}
string fileName = GetFileName(error);
int lineNumber = GetLineNumber(error);
string exceptionName = error.GetType().ToString();
string exceptionMessage = error.Message;
string providedFault = String.Empty;
string providedMessage = String.Empty;
if (fault != null)
{
providedFault = (fault.Code == null) ? "Unknown" : fault.Code.Name;
providedMessage = (fault.Reason == null || fault.Reason.Translations == null ||
fault.Reason.Translations.Count <= 0)
? "Unknown"
: fault.Reason.Translations[0].Text;
}
return new LogData(assemblyName, fileName, lineNumber, typeName, methodName, exceptionName, exceptionMessage,
providedFault, providedMessage);
}
public bool TryCreateException(Message message, MessageFault fault, out Exception exception)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
if (fault == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("fault");
}
bool flag = this.OnTryCreateException(message, fault, out exception);
if (flag)
{
if (exception == null)
{
Exception exception2 = new InvalidOperationException(System.ServiceModel.SR.GetString("FaultConverterDidNotCreateException", new object[] { base.GetType().Name }));
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception2);
}
return flag;
}
if (exception != null)
{
Exception exception3 = new InvalidOperationException(System.ServiceModel.SR.GetString("FaultConverterCreatedException", new object[] { base.GetType().Name }), exception);
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception3);
}
return flag;
}
protected override bool OnTryCreateException (
Message message, MessageFault fault, out Exception error)
{
if (message == null)
throw new ArgumentNullException ("message");
if (fault == null)
throw new ArgumentNullException ("fault");
error = null;
FaultCode fc;
if (version.Envelope.Equals (EnvelopeVersion.Soap11))
fc = fault.Code;
else
fc = fault.Code.SubCode;
if (fc == null)
return false;
string msg = fault.Reason.GetMatchingTranslation ().Text;
if (fc.Namespace == message.Version.Addressing.Namespace) {
switch (fc.Name) {
case "ActionNotSupported":
error = new ActionNotSupportedException (msg);
return true;
case "DestinationUnreachable":
error = new EndpointNotFoundException (msg);
return true;
}
}
return false;
}
static void AreMessageFaultEqual (MessageFault a, MessageFault b, string label)
{
Assert.AreEqual (a.Actor, b.Actor, label + ".Actor");
Assert.AreEqual (a.Code, b.Code, label + ".Code");
Assert.AreEqual (a.HasDetail, b.HasDetail, label + ".HasDetail");
Assert.AreEqual (a.Node, b.Node, label + ".Node");
Assert.AreEqual (a.Reason, b.Reason, label + ".Reason");
}
public SdmxMessageFault(MessageFault messageFault, string nameSpace)
{
if (messageFault == null)
{
throw new ArgumentNullException("messageFault");
}
this._messageFault = messageFault;
this._nameSpace = nameSpace;
}
public FaultException(MessageFault fault) : base(GetSafeReasonText(GetReason(fault)))
{
if (fault == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("fault");
}
this.code = EnsureCode(fault.Code);
this.reason = EnsureReason(fault.Reason);
this.fault = fault;
}
public FaultException (MessageFault fault, string action)
{
if (fault == null)
throw new ArgumentNullException ("fault");
//if (action == null)
// throw new ArgumentNullException ("action");
this.fault = fault;
this.action = action;
}
public void Fault(Message message, MessageFault fault)
{
if (this.CheckMessage(message, false) != null)
{
this.state.Perf.FaultsReceivedCountPerInterval.Increment();
}
if (DebugTrace.Info)
{
DebugTrace.Trace(TraceLevel.Info, "Ignoring {0} fault from completion participant at {1}: {2}", Library.GetFaultCodeName(fault), Ports.TryGetFromAddress(message), Library.GetFaultCodeReason(fault));
}
}
public static FaultCode GetBaseFaultCode(MessageFault fault)
{
FaultCode subCode = fault.Code;
if (subCode != null)
{
while (subCode.SubCode != null)
{
subCode = subCode.SubCode;
}
}
return subCode;
}
public static void LogError(Exception error,MessageFault fault)
{
LogbookEntryClient entry = CreateLogbookEntry(error,fault);
try
{
LogbookManagerClient proxy = new LogbookManagerClient();
proxy.LogEntry(entry);
proxy.Close();
}
catch
{}
}
public static void LogError(Exception error, MessageFault fault)
{
string message = CreateLogbookentry(error, fault).ToString();
if (error is SemanticException)
{
s_Logger.Debug(message, error);
}
else
{
s_Logger.Error(message, error);
}
}
static void Main(string[] args)
{
FaultCode code = FaultCode.CreateSenderFaultCode("calcuError", "http://www.artech.com");
FaultReasonText reasonText1 = new FaultReasonText("Divided by zero!", "en-US");
FaultReasonText reasonText2 = new FaultReasonText("试图除以零!", "zh-CN");
FaultReason reason = new FaultReason(new FaultReasonText[] { reasonText1, reasonText2 });
MessageFault fault = MessageFault.CreateFault(code, reason);
string action = "http://www.artech.com/divideFault";
using (Message message = Message.CreateMessage(MessageVersion.Default, fault, action))
{
WriteMessage(message, "message.xml");
}
}
protected override FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo> faultInfos;
if (action != null)
{
faultInfos = new List <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo>();
for (int i = 0; i < xmlSerializerFaultContractInfos.Count; i++)
{
if (xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == action ||
xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == MessageHeaders.WildcardAction)
{
faultInfos.Add(xmlSerializerFaultContractInfos[i]);
}
}
}
else
{
faultInfos = xmlSerializerFaultContractInfos;
}
Type detailType = null;
object detailObj = null;
for (int i = 0; i < faultInfos.Count; i++)
{
XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo faultInfo = faultInfos[i];
XmlDictionaryReader detailReader = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = faultInfo.Serializer;
if (serializer.IsStartObject(detailReader))
{
detailType = faultInfo.FaultContractInfo.Detail;
try
{
detailObj = serializer.ReadObject(detailReader);
FaultException faultException = CreateFaultException(messageFault, action,
detailObj, detailType, detailReader);
if (faultException != null)
{
return(faultException);
}
}
catch (SerializationException)
{
}
}
}
return(new FaultException(messageFault, action));
}
public static FaultException CreateFault(MessageFault messageFault, string action, params System.Type[] faultDetailTypes)
{
if (messageFault == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageFault");
}
if (faultDetailTypes == null)
{
throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("faultDetailTypes");
}
DataContractSerializerFaultFormatter formatter = new DataContractSerializerFaultFormatter(faultDetailTypes);
return(formatter.Deserialize(messageFault, action));
}
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
if (error is FaultException)
{
return;
}
//bool serviceDebug = OperationContext.Current.EndpointDispatcher.ChannelDispatcher.IncludeExceptionDetailInFaults;
FaultException faultException = new FaultException("The server encountered an error of type " + error.GetType());
MessageFault faultMessage = faultException.CreateMessageFault();
fault = Message.CreateMessage(version, faultMessage, faultException.Action);
}
public void CreateFaultMessageAndWrite()
{
string xml = @"<s:Envelope xmlns:a=""http://www.w3.org/2005/08/addressing"" xmlns:s=""http://www.w3.org/2003/05/soap-envelope""><s:Header><a:Action s:mustUnderstand=""1"">http://www.w3.org/2005/08/addressing/fault</a:Action></s:Header><s:Body><s:Fault><s:Code><s:Value xmlns:a=""urn:me"">a:me</s:Value></s:Code><s:Reason><s:Text xml:lang="""">am so lazy</s:Text></s:Reason></s:Fault></s:Body></s:Envelope>";
FaultCode fc = new FaultCode("me", "urn:me");
FaultReasonText ft = new FaultReasonText("am so lazy", CultureInfo.InvariantCulture);
Message msg = Message.CreateMessage(
MessageVersion.Default,
MessageFault.CreateFault(fc, new FaultReason(ft)),
"http://www.w3.org/2005/08/addressing/fault");
// It should be XML comparison, not string comparison
Assert.AreEqual(xml, GetSerializedMessage(msg));
}
public CoreWCF.Channels.Message Untyped_MethodReturns(CoreWCF.Channels.Message msgIn)
{
CoreWCF.Channels.MessageVersion mv = OperationContext.Current.IncomingMessageHeaders.MessageVersion;
string faultToThrow = "Test fault thrown from a service";
if (msgIn != null)
{
return(Message.CreateMessage(mv, MessageFault.CreateFault(new FaultCode("Sender"), new FaultReason("Unspecified ServiceModel Fault"), faultToThrow,
new System.Runtime.Serialization.DataContractSerializer(typeof(string)), "", ""), ""));
}
return(Message.CreateMessage(mv, MessageFault.CreateFault(new FaultCode("Sender"), new FaultReason("Unspecified ServiceModel Fault"), "unspeficied",
new System.Runtime.Serialization.DataContractSerializer(typeof(string)), "", ""), ""));
}
/// <summary>
/// ProvideFault
/// </summary>
/// <param name="ex">ex</param>
/// <param name="version">version</param>
/// <param name="msg">msg</param>
public void ProvideFault(Exception ex, MessageVersion version, ref Message msg)
{
//
//在这里处理服务端的消息，将消息写入服务端的日志
//
string err = string.Format("调用WCF接口 '{0}' 出错", ex.TargetSite.ReflectedType.FullName + "." + ex.TargetSite.Name) + Environment.NewLine + ex.Message;
var newEx = new FaultException(err);
ILog alog = log4net.LogManager.GetLogger("SysRun");
alog.Error(string.Format("调用WCF接口 '{0}' 出错", ex.TargetSite.ReflectedType.FullName + "." + ex.TargetSite.Name) + Environment.NewLine + ex.Message + Environment.NewLine + ex.StackTrace); //+ex.TargetSite.GetParameters
MessageFault msgFault = newEx.CreateMessageFault();
msg = Message.CreateMessage(version, msgFault, newEx.Action);
}
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
if (error is FaultException)
{
return;
}
BusinessServiceException businessFault = new BusinessServiceException(error);
FaultException <BusinessServiceException> faultEx =
new FaultException <BusinessServiceException>(businessFault, "Error occurs in business service",
new FaultCode("BusinessServiceException"));
MessageFault msgFault = faultEx.CreateMessageFault();
fault = Message.CreateMessage(version, msgFault, faultEx.Action);
}
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
if (error is FaultException)
{
return;
}
FaultException faultException
= new FaultException(error.Message, new FaultCode("InnerServiceException"));
MessageFault msg = faultException.CreateMessageFault();
fault = Message.CreateMessage(version, msg, "null");
}
/*
* Show Message Box With SOAP Error If We Receive A Fault Code Back From Service
*
*/
private void LogSoapException(FaultException e)
{
MessageFault message = e.CreateMessageFault();
XmlElement errorDetail = message.GetDetail <XmlElement>();
XmlNodeList errorDetails = errorDetail.ChildNodes;
String fullErrorDetails = "";
for (int i = 0; i < errorDetails.Count; i++)
{
fullErrorDetails += errorDetails.Item(i).Name + ": " + errorDetails.Item(i).InnerText + "\n";
}
_log.Error("An Error Occured With Royal Mail Api Service: " + message.Reason.ToString() + "\n\n" + fullErrorDetails);
}
public object Invoke(object instance, object[] inputs, out object[] outputs)
{
FaultException exception;
ServiceChannel serviceChannel;
outputs = EmptyArray <object> .Allocate(0);
Message message = inputs[0] as Message;
if (message != null)
{
string action = message.Headers.Action;
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, 0x80037, System.ServiceModel.SR.GetString("TraceCodeUnhandledAction"), new StringTraceRecord("Action", action), this, null, message);
}
FaultCode code = FaultCode.CreateSenderFaultCode("ActionNotSupported", message.Version.Addressing.Namespace);
FaultReason reason = new FaultReason(System.ServiceModel.SR.GetString("SFxNoEndpointMatchingContract", new object[] { action }));
exception = new FaultException(reason, code);
System.ServiceModel.Dispatcher.ErrorBehavior.ThrowAndCatch(exception);
serviceChannel = OperationContext.Current.InternalServiceChannel;
OperationContext.Current.OperationCompleted += delegate(object sender, EventArgs e) {
ChannelDispatcher channelDispatcher = this.dispatchRuntime.ChannelDispatcher;
if (!channelDispatcher.HandleError(exception) && serviceChannel.HasSession)
{
try
{
serviceChannel.Close(ChannelHandler.CloseAfterFaultTimeout);
}
catch (Exception exception1)
{
if (Fx.IsFatal(exception1))
{
throw;
}
channelDispatcher.HandleError(exception1);
}
}
};
if (this.dispatchRuntime.shared.EnableFaults)
{
MessageFault fault = MessageFault.CreateFault(code, reason, action);
return(Message.CreateMessage(message.Version, fault, message.Version.Addressing.DefaultFaultAction));
}
OperationContext.Current.RequestContext.Close();
OperationContext.Current.RequestContext = null;
}
return(null);
}
/// <summary>
/// 启用创建从服务方法过程中的异常返回的自定义 System.ServiceModel.FaultException<TDetail>。
/// </summary>
/// <param name="error"> 服务操作过程中引发的 System.Exception 对象。</param>
/// <param name="version">消息的 SOAP 版本。</param>
/// <param name="fault">双工情况下，返回到客户端或服务的 System.ServiceModel.Channels.Message 对象。</param>
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
var context = OperationContext.Current;
if (context == null)
{
return;
}
////获取传进的消息属性
MessageProperties properties = context.IncomingMessageProperties;
var endpoint = properties[RemoteEndpointMessageProperty.Name] as RemoteEndpointMessageProperty;
var message = context.RequestContext.RequestMessage;
var action = message.Headers.Action;
var document = new XmlDocument();
document.LoadXml(message.ToString());
var nodes = document.GetElementsByTagName(action.Substring(action.LastIndexOf('/') + 1));
var dic = new Dictionary <string, string>();
var dis = IsLogDisable(context, action);
dic.Add("url", context.Host.BaseAddresses[0].AbsolutePath + action.Substring(action.LastIndexOf('/')));
dic.Add("host", context.Host.BaseAddresses[0].AbsoluteUri);
var xmlNode = nodes.Item(0);
if (xmlNode != null)
{
dic.Add("parameter", xmlNode.InnerXml);
}
dic.Add("message", error.Message);
//int errorCode = error is ServiceException ? ((ServiceException)error).Code : 0;
//var faultException = error is FaultException ?
// (FaultException)error : new FaultException<ErrorInfo>(new ErrorInfo
// {
// Message = error.Message,
// ErrorCode = errorCode
// }, error.Message);
var faultException =
new FaultException(error.Message);
MessageFault messageFault = faultException.CreateMessageFault();
fault = Message.CreateMessage(version, messageFault, action);
Log.Write(
string.Format("\r\n请求： {0} + ！\r\n调用信息：{1}\r\n参数：{2}\r\n返回信息：{3}", dic["host"], dic["url"],
dic["parameter"], dic["message"]), MessageType.Error, this.GetType(), error);
//ExceptionHelper.LogException(error, null, dic, null);
}
public async Task <string> CreateVideoAsync(IStorageFile file, Video v)
{
VideoSubmition videoSubmition = new VideoSubmition
{
Tags = v.Tags,
Title = v.Title,
Synopse = v.Synopse
};
Video createdVideo = null;
try
{
using (EnsureCredentialsUseContext context = new EnsureCredentialsUseContext(
this.Username, this.Password, this.AccessKey, _client.InnerChannel))
{
createdVideo = await this._client.AddVideoPostAsync(videoSubmition, null);
}
}
catch (FaultException faultException)
{
MessageFault messageFault = faultException.CreateMessageFault();
if (messageFault.HasDetail)
{
string innerErrorXml;
using (var xmlReader = messageFault.GetReaderAtDetailContents())
{
innerErrorXml = xmlReader.ReadInnerXml();
}
if (innerErrorXml != null)
{
throw new Exception(innerErrorXml);
}
throw;
}
}
string token = createdVideo.Token;
BackgroundUploader uploader = new BackgroundUploader();
UploadOperation uploadOperation =
await VideosServiceClient.CreateUploadOperationForCreateVideo(file, token, uploader);
await uploadOperation.StartAsync();
return(await GetResponseMessage(uploadOperation));
}
public ActionResult Grabar(int id, string placa, string clase, string marca, string modelo,
string color, int motor, int asientos, int puertas, string fecinscripcion,
string anio, string estado)
{
try
{
Movilidad busAGrabar = new Movilidad()
{
Id = id,
Placa = placa,
Clase = clase,
Marca = marca,
Modelo = modelo,
Color = color,
Motor = motor,
Asientos = asientos,
Puertas = puertas,
FeInscripcion = DateTime.Parse(fecinscripcion),
Año = anio,
Estado = estado
};
Movilidad bus = null;
if (busAGrabar.Id == 0)
{
bus = new BusesClient().CrearMovilidad(busAGrabar);
}
else
{
bus = new BusesClient().ModificarMovilidad(busAGrabar);
}
if (bus != null)
{
return(Json("Success", JsonRequestBehavior.AllowGet));
}
else
{
return(Json("Datos incorrectos", JsonRequestBehavior.AllowGet));
}
}
catch (FaultException error)
{
MessageFault fault = error.CreateMessageFault();
BusWS.RepetidoException detail = fault.GetDetail <BusWS.RepetidoException>();
return(Json(detail.descripcion, JsonRequestBehavior.AllowGet));
}
}
private static MethodFault GetVIServerFault(FaultException soapEx)
{
if (soapEx == null)
{
throw new ArgumentNullException("soapEx");
}
PropertyInfo property = soapEx.GetType().GetTypeInfo().GetProperty("Detail");
VimApi_65.MethodFault methodFault;
if (property != (PropertyInfo)null)
{
methodFault = property.GetValue((object)soapEx) as VimApi_65.MethodFault;
}
else
{
MessageFault messageFault = soapEx.CreateMessageFault();
XmlSerializer xmlSerializer = FaultUtility.GetFaultSerializer();
if (xmlSerializer == null)
{
/* XElement xelement = (XElement)XNode.ReadFrom((XmlReader)messageFault.GetReaderAtDetailContents());
* System.Type type = typeof(VimApi_65.MethodFault).Assembly.GetType(string.Format("{0}.{1}", (object)typeof(VimApi_65.MethodFault).Namespace, (object)xelement.Attribute(XName.Get("type", "http://www.w3.org/2001/XMLSchema-instance")).Value));
* XmlRootAttribute xmlRootAttribute = new XmlRootAttribute(xelement.Name.LocalName);
* // ISSUE: variable of the null type
* __Null local1 = null;
* // ISSUE: variable of the null type
* __Null local2 = null;
* XmlRootAttribute root = xmlRootAttribute;
* string defaultNamespace = "urn:vim25";
* xmlSerializer = new XmlSerializer(type, (XmlAttributeOverrides)local1, (System.Type[])local2, root, defaultNamespace); */
XElement xElement = (XElement)XNode.ReadFrom(messageFault.GetReaderAtDetailContents());
XAttribute xAttribute = xElement.Attribute(XName.Get("type", "http://www.w3.org/2001/XMLSchema-instance"));
string name = string.Format("{0}.{1}", typeof(VimApi_65.MethodFault).Namespace, xAttribute.Value);
Type arg_D0_0 = typeof(VimApi_65.MethodFault).Assembly.GetType(name);
XmlRootAttribute root = new XmlRootAttribute(xElement.Name.LocalName);
xmlSerializer = new XmlSerializer(arg_D0_0, null, null, root, "urn:vim25");
}
StringReader stringReader = new StringReader(messageFault.GetDetail <XElement>().ToString().Replace("xsd:", ""));
using (XmlReader xmlReader = XmlReader.Create((TextReader)stringReader, new XmlReaderSettings()
{
ConformanceLevel = ConformanceLevel.Fragment,
CloseInput = true
}))
{
int content = (int)xmlReader.MoveToContent();
methodFault = xmlSerializer.Deserialize(xmlReader) as VimApi_65.MethodFault;
}
}
return(VIConvert.ToVim((object)methodFault) as MethodFault);
}
protected override FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo> faultInfos;
if (action != null)
{
faultInfos = new List <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo>();
for (int i = 0; i < _xmlSerializerFaultContractInfos.Count; i++)
{
if (_xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == action ||
_xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == MessageHeaders.WildcardAction)
{
faultInfos.Add(_xmlSerializerFaultContractInfos[i]);
}
}
}
else
{
faultInfos = _xmlSerializerFaultContractInfos;
}
for (int i = 0; i < faultInfos.Count; i++)
{
XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo faultInfo = faultInfos[i];
XmlDictionaryReader detailReader = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = faultInfo.Serializer;
if (serializer.IsStartObject(detailReader))
{
Type detailType = faultInfo.FaultContractInfo.Detail;
try
{
object detailObj = serializer.ReadObject(detailReader);
FaultException faultException = CreateFaultException(messageFault, action,
detailObj, detailType, detailReader);
if (faultException != null)
{
return(faultException);
}
}
#pragma warning disable CA1031 // Do not catch general exception types - if we can't deserialie the message fault detail, return plain FaultException
catch (SerializationException)
{
}
#pragma warning restore CA1031 // Do not catch general exception types
}
}
return(new FaultException(messageFault, action));
}
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
if (error is FaultException)
{
return;
}
string errorDescription = string.Format("{0} {1} {2}", error.Message,
Environment.NewLine,
error.StackTrace);
FaultException exception = new FaultException(errorDescription);
MessageFault msgFault = exception.CreateMessageFault();
fault = Message.CreateMessage(version, msgFault, null);
}
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));
}
}
public Message CreateErrorResponse(Exception excp)
{
FaultException fe = new FaultException(excp.Message);
MessageFault fault = fe.CreateMessageFault();
Message response = Message.CreateMessage(MessageVersion.Default, fault, null);
HttpResponseMessageProperty http = new HttpResponseMessageProperty();
http.StatusCode = System.Net.HttpStatusCode.OK;
http.SuppressEntityBody = true;
response.Properties.Add(HttpResponseMessageProperty.Name, http);
return(response);
}
public static FaultException ConstructFaultException(Message response)
{
Type[] typeArray = new Type[9];
typeArray[0] = typeof(FragmentDialect);
typeArray[1] = typeof(AttributeTypeNotValid);
typeArray[2] = typeof(EnumerateFault);
typeArray[3] = typeof(FaultDetail);
typeArray[4] = typeof(FaultDetail1);
typeArray[5] = typeof(SupportedSelectOrSortDialect);
typeArray[6] = typeof(SupportedDialect);
typeArray[7] = typeof(PullFault);
typeArray[8] = typeof(RenewFault);
Type[] typeArray1 = typeArray;
return(FaultException.CreateFault(MessageFault.CreateFault(response, 0x500000), typeArray1));
}
public static FaultException CreateFault(MessageFault messageFault, string action, params Type[] faultDetailTypes)
{
if (messageFault == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(messageFault));
}
if (faultDetailTypes == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(faultDetailTypes));
}
DataContractSerializerFaultFormatter faultFormatter = new DataContractSerializerFaultFormatter(faultDetailTypes);
return(faultFormatter.Deserialize(messageFault, action));
}
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
if (error is EntityValidationException)
{
LoggerServiceHelper.Current.TraceException(this, error);
MessageFault messageFault = MessageFault.CreateFault(
new FaultCode("Sender"),
new FaultReason(error.Message),
error,
new NetDataContractSerializer());
fault = Message.CreateMessage(version, messageFault, null);
}
}
public void ShouldGetFaultExceptionWithoutPolicy()
{
ExceptionShieldingErrorHandler shielding = new ExceptionShieldingErrorHandler();
FaultException faultException = GetFaultException("test", SoapException.ServerFaultCode.Name);
Message message = Message.CreateMessage(MessageVersion.Default, faultException.CreateMessageFault(), "");
shielding.ProvideFault(faultException, MessageVersion.Default, ref message);
MessageFault actualFault = GetFaultFromMessage(message);
MessageFault expectedFault = faultException.CreateMessageFault();
Assert.AreEqual(expectedFault.Reason.ToString(), actualFault.Reason.ToString());
Assert.AreEqual(expectedFault.HasDetail, actualFault.HasDetail);
Assert.AreEqual(expectedFault.Code.IsReceiverFault, actualFault.Code.IsReceiverFault);
}
/// <summary>
/// Put the request item into the storage. and the storage will cache the requests in the memory
/// until the front end call the flush method. the async result will return the BrokerQueueItem.
/// </summary>
/// <param name="context">the request context relate to the message</param>
/// <param name="msg">the request message</param>
/// <param name="asyncState">the asyncState relate to the message</param>
public override async Task PutRequestAsync(Telepathy.ServiceBroker.FrontEnd.RequestContextBase context, Message msg, object asyncState)
{
this.queue.Enqueue(new BrokerQueueItem(context, msg, asyncState));
if (this.directReply)
{
MessageFault fault = MessageFault.CreateFault(FaultCode.CreateReceiverFaultCode("DummyReply", "http://hpc.microsoft.com"), "DummyReply");
Message reply = Message.CreateMessage(context.MessageVersion, fault, msg.Headers.Action + "Response");
if (context.MessageVersion == MessageVersion.Default)
{
reply.Headers.RelatesTo = msg.Headers.MessageId;
}
context.Reply(reply, TimeSpan.MaxValue);
}
}
/// <summary>
/// Processa a respota recebida.
/// </summary>
/// <param name="reply"></param>
/// <param name="correlationState"></param>
public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
{
if (reply.IsFault)
{
var buffer = reply.CreateBufferedCopy(Int32.MaxValue);
var copy = buffer.CreateMessage();
reply = buffer.CreateMessage();
var messageFault = MessageFault.CreateFault(copy, 0x10000);
if ((messageFault.Code.Name == InvalidTokenFaultReasonCode || messageFault.Code.Name == EmptyTokenFaultReasonCode) && messageFault.Code.Namespace == Namespace)
{
throw new InvalidSecurityTokenException(messageFault.Reason.ToString(), FaultException.CreateFault(messageFault));
}
throw FaultException.CreateFault(messageFault);
}
}
protected override bool OnTryCreateException(Message message, MessageFault fault, out Exception exception)
{
if (this.innerChannel == null)
{
exception = null;
return false;
}
FaultConverter property = this.innerChannel.GetProperty<FaultConverter>();
if (property != null)
{
return property.TryCreateException(message, fault, out exception);
}
exception = null;
return false;
}
public void ShouldReturnReceiverFault()
{
ExceptionShieldingErrorHandler shielding = new ExceptionShieldingErrorHandler("CustomPolicy");
Message message = GetDefaultMessage();
Exception exception = new NotSupportedException("NotSupportedException");
shielding.ProvideFault(exception, MessageVersion.Default, ref message);
MessageFault fault = GetFaultFromMessage(message);
Assert.IsTrue(fault.Code.IsReceiverFault);
Assert.IsFalse(string.IsNullOrEmpty(fault.Reason.ToString()));
Assert.IsFalse(fault.HasDetail);
CheckHandlingInstanceId("DefaultLogs.txt", fault.Reason.ToString());
}
/// <summary>
/// 将Exception转化为FaultException
/// </summary>
/// <param name="error">Exception</param>
/// <param name="version">MessageVersion</param>
/// <param name="fault">错误消息</param>
public void ProvideFault(Exception error, MessageVersion version, ref Message fault)
{
if (error is FaultException)
{
return;
}
FaultCodeAttribute attribute = error.GetType().GetCustomAttribute <FaultCodeAttribute>();
var faultCode = attribute == null?error.GetType().Name : attribute.Name;
FaultException faultException = new FaultException(error.Message, new FaultCode(faultCode));
MessageFault messageFault = faultException.CreateMessageFault();
fault = Message.CreateMessage(version, messageFault, faultException.Action);
}
private void OnReceive(ref Message reply)
{
if (reply.IsFault && reply.Headers.Action == FaultMessage.FaultAction)
{
var fault = MessageFault.CreateFault(reply, int.MaxValue);
if (fault.Code.SubCode.Name == FaultMessage.FaultSubCodeName &&
fault.Code.SubCode.Namespace == FaultMessage.FaultSubCodeNamespace)
{
var exception = (FaultException <FaultMessage>)FaultException
.CreateFault(fault, typeof(FaultMessage));
throw GetException(exception.Detail);
}
}
}
private void HandleFault(FaultContractWrapperException faultContractWrapper, ref Message fault)
{
try
{
MessageFault messageFault = BuildMessageFault(faultContractWrapper);
fault = Message.CreateMessage(fault.Version, messageFault, GetFaultAction(faultContractWrapper) ?? fault.Headers.Action);
}
catch (Exception unhandledException)
{
// There was an error during MessageFault build process, so treat it as an Unhandled Exception
// log the exception and send an unhandled server exception
Guid handlingInstanceId = ExceptionUtility.LogServerException(unhandledException);
HandleFault(unhandledException, ref fault, handlingInstanceId, null);
}
}
protected override FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList<XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo> faultInfos;
if (action != null)
{
faultInfos = new List<XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo>();
for (int i = 0; i < _xmlSerializerFaultContractInfos.Count; i++)
{
if (_xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == action
|| _xmlSerializerFaultContractInfos[i].FaultContractInfo.Action == MessageHeaders.WildcardAction)
{
faultInfos.Add(_xmlSerializerFaultContractInfos[i]);
}
}
}
else
{
faultInfos = _xmlSerializerFaultContractInfos;
}
Type detailType = null;
object detailObj = null;
for (int i = 0; i < faultInfos.Count; i++)
{
XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo faultInfo = faultInfos[i];
XmlDictionaryReader detailReader = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = faultInfo.Serializer;
if (serializer.IsStartObject(detailReader))
{
detailType = faultInfo.FaultContractInfo.Detail;
try
{
detailObj = serializer.ReadObject(detailReader);
FaultException faultException = CreateFaultException(messageFault, action,
detailObj, detailType, detailReader);
if (faultException != null)
return faultException;
}
catch (SerializationException)
{
}
}
}
return new FaultException(messageFault, action);
}
public static string GetFaultCodeName(MessageFault fault)
{
FaultCode subCode = fault.Code;
if (subCode == null)
{
return "unknown";
}
if (subCode.SubCode != null)
{
subCode = subCode.SubCode;
if (subCode == null)
{
return "unknown";
}
}
return subCode.Name;
}
protected override FaultException CreateFaultException(MessageFault messageFault, string action)
{
IList<XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo> xmlSerializerFaultContractInfos;
if (action != null)
{
xmlSerializerFaultContractInfos = new List<XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo>();
for (int j = 0; j < this.xmlSerializerFaultContractInfos.Count; j++)
{
if ((this.xmlSerializerFaultContractInfos[j].FaultContractInfo.Action == action) || (this.xmlSerializerFaultContractInfos[j].FaultContractInfo.Action == "*"))
{
xmlSerializerFaultContractInfos.Add(this.xmlSerializerFaultContractInfos[j]);
}
}
}
else
{
xmlSerializerFaultContractInfos = this.xmlSerializerFaultContractInfos;
}
System.Type detailType = null;
object detailObj = null;
for (int i = 0; i < xmlSerializerFaultContractInfos.Count; i++)
{
XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo info = xmlSerializerFaultContractInfos[i];
XmlDictionaryReader readerAtDetailContents = messageFault.GetReaderAtDetailContents();
XmlObjectSerializer serializer = info.Serializer;
if (serializer.IsStartObject(readerAtDetailContents))
{
detailType = info.FaultContractInfo.Detail;
try
{
detailObj = serializer.ReadObject(readerAtDetailContents);
FaultException exception = base.CreateFaultException(messageFault, action, detailObj, detailType, readerAtDetailContents);
if (exception != null)
{
return exception;
}
}
catch (SerializationException)
{
}
}
}
return new FaultException(messageFault, action);
}
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 static string GetFaultCodeReason(MessageFault fault)
{
FaultReasonText matchingTranslation;
FaultReason reason = fault.Reason;
if (reason == null)
{
return "unknown";
}
try
{
matchingTranslation = reason.GetMatchingTranslation(CultureInfo.CurrentCulture);
}
catch (ArgumentException exception)
{
Microsoft.Transactions.Bridge.DiagnosticUtility.ExceptionUtility.TraceHandledException(exception, TraceEventType.Warning);
return "unknown";
}
return matchingTranslation.Text;
}
public static CoordinatorRegistrationFailedFault CreateFault(MessageFault fault)
{
string str;
if (fault == null)
{
str = Microsoft.Transactions.SR.GetString("CoordinatorRegistrationFailedReason");
}
else
{
string faultCodeName = Library.GetFaultCodeName(fault);
if (faultCodeName == null)
{
str = Microsoft.Transactions.SR.GetString("CoordinatorRegistrationFaultedUnknownReason");
}
else
{
str = Microsoft.Transactions.SR.GetString("CoordinatorRegistrationFaultedReason", new object[] { faultCodeName });
}
}
return new CoordinatorRegistrationFailedFault(str);
}
private static ExceptionLogbookEntry CreateLogbookentry(Exception error, MessageFault fault)
{
string typeName;
string methodName;
string assemblyName = typeName = methodName = "Unknown";
try
{
if (error.TargetSite != null)
{
assemblyName = error.TargetSite.Module.Assembly.GetName().Name;
methodName = error.TargetSite.Name;
if (error.TargetSite.DeclaringType != null)
{
typeName = error.TargetSite.DeclaringType.Name;
}
}
}
catch (Exception)
{
assemblyName = "Could not reflect assembly name.";
}
string fileName = GetFileName(error);
int lineNumber = GetLineNumber(error);
string exceptionName = error.GetType().ToString();
string exceptionMessage = error.Message;
string providedFault = string.Empty;
string providedMessage = string.Empty;
if (fault != null)
{
providedFault = fault.Code.Name;
providedMessage = fault.Reason.Translations[0].Text;
}
return new ExceptionLogbookEntry(assemblyName, fileName, lineNumber, typeName, methodName, exceptionName, exceptionMessage, providedFault, providedMessage);
}
public FaultException(MessageFault fault)
: base(FaultException.GetSafeReasonText(GetReason(fault)))
{
if (fault == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("fault");
this.code = FaultException.EnsureCode(fault.Code);
this.reason = FaultException.EnsureReason(fault.Reason);
this.fault = fault;
}
internal static string GetSafeReasonText(MessageFault messageFault)
{
if (messageFault == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageFault");
return GetSafeReasonText(messageFault.Reason);
}
#pragma warning restore 688
static FaultReason GetReason(MessageFault fault)
{
if (fault == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("fault");
}
return fault.Reason;
}
public static FaultException CreateFault(MessageFault messageFault, string action, params Type[] faultDetailTypes)
{
if (messageFault == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("messageFault");
}
if (faultDetailTypes == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("faultDetailTypes");
}
DataContractSerializerFaultFormatter faultFormatter = new DataContractSerializerFaultFormatter(faultDetailTypes);
return faultFormatter.Deserialize(messageFault, action);
}
public static FaultException CreateFault(MessageFault messageFault, params Type[] faultDetailTypes)
{
return CreateFault(messageFault, null, faultDetailTypes);
}
public FaultException(MessageFault fault, string action)
: base(FaultException.GetSafeReasonText(GetReason(fault)))
{
if (fault == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("fault");
this.code = fault.Code;
this.reason = fault.Reason;
this.fault = fault;
this.action = action;
}
public static bool TryCreateFault12(ReliableMessagingVersion reliableMessagingVersion, Message message,
MessageFault fault, out WsrmHeaderFault wsrmFault)
{
// All wsrm header faults must be sender or receiver faults.
if (!fault.Code.IsSenderFault && !fault.Code.IsReceiverFault)
{
wsrmFault = null;
return false;
}
if ((fault.Code.SubCode == null)
|| (fault.Code.SubCode.Namespace != WsrmIndex.GetNamespaceString(reliableMessagingVersion)) || !fault.HasDetail)
{
wsrmFault = null;
return false;
}
string subcodeName = fault.Code.SubCode.Name;
XmlDictionaryReader detailReader = fault.GetReaderAtDetailContents();
wsrmFault = CreateWsrmHeaderFault(reliableMessagingVersion, fault.Code, subcodeName, fault.Reason,
detailReader);
return (wsrmFault != null);
}
public static bool TryCreateFault11(ReliableMessagingVersion reliableMessagingVersion, Message message,
MessageFault fault, int index, out WsrmHeaderFault wsrmFault)
{
if (index == -1)
{
wsrmFault = null;
return false;
}
// All wsrm header faults must be sender or receiver faults.
if (!fault.Code.IsSenderFault && !fault.Code.IsReceiverFault)
{
wsrmFault = null;
return false;
}
string subcodeName = WsrmSequenceFaultHeader.GetSubcode(message.Headers.GetReaderAtHeader(index),
reliableMessagingVersion);
if (subcodeName == null)
{
wsrmFault = null;
return false;
}
string detailName;
string detailNamespace;
LookupDetailInformation(reliableMessagingVersion, subcodeName, out detailName, out detailNamespace);
XmlDictionaryReader detailReader = WsrmSequenceFaultHeader.GetReaderAtDetailContents(detailName,
detailNamespace, message.Headers.GetReaderAtHeader(index), reliableMessagingVersion);
if (detailReader == null)
{
wsrmFault = null;
return false;
}
wsrmFault = CreateWsrmHeaderFault(reliableMessagingVersion, fault.Code, subcodeName, fault.Reason,
detailReader);
if (wsrmFault != null)
{
message.Headers.UnderstoodHeaders.Add(message.Headers[index]);
return true;
}
else
{
return false;
}
}