static SendReply BuildFaultReplies(FaultDescription faultDescription, bool isMessageContract)
{
Fx.Assert(faultDescription != null, "fault Description cannot be null");
if (faultDescription.DetailType == TypeHelper.VoidType || faultDescription.DetailType == null)
{
throw FxTrace.Exception.ArgumentNullOrEmpty("FaultDescription.DetailType");
}
SendReply faultReply = new SendReply()
{
DisplayName = faultDescription.Name + "SendFaultReply",
Action = faultDescription.Action,
};
Type[] substitute = { faultDescription.DetailType };
Type faultType = typeof(FaultException <>).MakeGenericType(substitute);
if (isMessageContract)
{
faultReply.Content = new SendMessageContent()
{
Message = (InArgument)(InArgument.Create(faultType, ArgumentDirection.In)),
};
}
else
{
InArgument argument = (InArgument)(InArgument.Create(faultType, ArgumentDirection.In));
SendParametersContent faultReplyParameterContent = new SendParametersContent();
faultReplyParameterContent.Parameters.Add(faultDescription.Name, argument);
faultReply.Content = faultReplyParameterContent;
}
return(faultReply);
}
public static void AddFaultDescription(Receive activity, OperationDescription operation)
{
if (activity.HasFault)
{
foreach (SendReply sendFault in activity.FollowingFaults)
{
string action = null;
Type type = null;
action = sendFault.Action;
SendMessageContent sendReply = sendFault.InternalContent as SendMessageContent;
if (sendReply != null)
{
type = sendReply.InternalDeclaredMessageType;
}
else
{
SendParametersContent sendReplyParameters = sendFault.InternalContent as SendParametersContent;
if (sendReplyParameters != null)
{
type = sendReplyParameters.ArgumentTypes[0]; // Exception should be the only parameter in SendFault
}
}
Fx.Assert(type != null, "Exception type cannot be null!");
if (type.IsGenericType && type.GetGenericTypeDefinition() == FaultExceptionType)
{
Type faultType = type.GetGenericArguments()[0];
bool exists = false;
// We expect the number of fault types to be small, so we use iterative comparison
foreach (FaultDescription faultDescription in operation.Faults)
{
if (faultDescription.DetailType == faultType)
{
if (faultDescription.Action != action)
{
throw FxTrace.Exception.AsError(new ValidationException(SR.SendRepliesHaveSameFaultTypeDifferentAction));
}
else
{
exists = true;
break;
}
}
}
if (!exists)
{
FaultDescription faultDescription = MessageBuilder.CreateFaultDescription(operation, faultType, action);
operation.Faults.Add(faultDescription);
}
}
}
}
}
public static void MakeFault(OperationDescription op)
{
if (!op.Faults.Any(p => p.DetailType == typeof(ExceptionFault)))
{
FaultDescription fd = new FaultDescription(op.Name);
fd.DetailType = typeof(ExceptionFault);
op.Faults.Add(fd);
}
}
private void ApplyErrorBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint)
{
foreach (OperationDescription opDesc in contractDescription.Operations)
{
FaultDescription faultDescription = new FaultDescription(endpoint.Contract.Namespace + endpoint.Contract.Name + "/" + opDesc.Name + "ServiceErrorFault");
faultDescription.DetailType = typeof(ServiceError);
opDesc.Faults.Add(faultDescription);
}
}
protected override void OnOpening()
{
foreach (OperationDescription operation in this.Endpoint.Contract.Operations)
{
FaultDescription fault = new FaultDescription(ServiceExceptionDetail.FaultAction);
fault.DetailType = typeof(ServiceExceptionDetail);
operation.Faults.Add(fault);
}
base.OnOpening();
}
internal void SetFault(FaultDescription fault)
{
string str = string.Format("Code = {0}, Message = {1}", fault.ErrorCode, fault.Message);
if (string.IsNullOrEmpty(fault.ExtMessage))
Exception = new Exception(str);
else
Exception = new Exception(str, new Exception(fault.ExtMessage));
IsResponse = true;
IsError = true;
Wait.Set();
}
/// <summary>
/// Adds a fault to the service operation.
/// </summary>
private static void AddFault(OperationDescription operation, string faultName, Type faultType)
{
if (!operation.Faults.Any(fault => fault.Name == faultName))
{
FaultDescription faultDescription = new FaultDescription(string.Format("{0}/{1}/{2}", operation.DeclaringContract.Namespace, operation.DeclaringContract.Name, operation.Name));
faultDescription.Name = faultName;
faultDescription.Namespace = Constants.DataContractNamespace;
faultDescription.DetailType = faultType;
operation.Faults.Add(faultDescription);
}
}
public static FaultDescription CreateFaultDescription(OperationDescription operation, Type faultType, string overridingAction)
{
string name = NamingHelper.TypeName(faultType) + "Fault";
string action = overridingAction ?? (NamingHelper.GetMessageAction(operation, false) + name);
FaultDescription description = new FaultDescription(action)
{
Namespace = operation.DeclaringContract.Namespace,
DetailType = faultType
};
description.SetNameOnly(new System.ServiceModel.Description.XmlName(name));
return(description);
}
public static FaultDescription CreateFaultDescription(OperationDescription operation, Type faultType, string overridingAction)
{
string name = NamingHelper.TypeName(faultType) + TypeLoader.FaultSuffix;
string action = overridingAction ?? NamingHelper.GetMessageAction(operation, false) + name;
FaultDescription result = new FaultDescription(action)
{
Namespace = operation.DeclaringContract.Namespace,
DetailType = faultType
};
result.SetNameOnly(new XmlName(name));
return(result);
}
public static void AddFaultDescription(Receive activity, OperationDescription operation)
{
if (activity.HasFault)
{
foreach (SendReply reply in activity.FollowingFaults)
{
string overridingAction = null;
System.Type internalDeclaredMessageType = null;
overridingAction = reply.Action;
SendMessageContent internalContent = reply.InternalContent as SendMessageContent;
if (internalContent != null)
{
internalDeclaredMessageType = internalContent.InternalDeclaredMessageType;
}
else
{
SendParametersContent content2 = reply.InternalContent as SendParametersContent;
if (content2 != null)
{
internalDeclaredMessageType = content2.ArgumentTypes[0];
}
}
if (internalDeclaredMessageType.IsGenericType && (internalDeclaredMessageType.GetGenericTypeDefinition() == FaultExceptionType))
{
System.Type faultType = internalDeclaredMessageType.GetGenericArguments()[0];
bool flag = false;
foreach (FaultDescription description in operation.Faults)
{
if (description.DetailType == faultType)
{
if (description.Action != overridingAction)
{
throw System.ServiceModel.Activities.FxTrace.Exception.AsError(new ValidationException(System.ServiceModel.Activities.SR.SendRepliesHaveSameFaultTypeDifferentAction));
}
flag = true;
break;
}
}
if (!flag)
{
FaultDescription item = MessageBuilder.CreateFaultDescription(operation, faultType, overridingAction);
operation.Faults.Add(item);
}
}
}
}
}
private FaultDescription MakeFault(Type detailType)
{
string action = detailType.Name;
DescriptionAttribute description = (DescriptionAttribute)
Attribute.GetCustomAttribute(detailType, typeof(DescriptionAttribute));
if (description != null)
{
action = description.Description;
}
FaultDescription fd = new FaultDescription(action);
fd.DetailType = detailType;
fd.Name = detailType.Name;
return(fd);
}
public static void ValidateFault(NativeActivityContext context, OperationDescription targetOperation, string overridingAction, Type faultType)
{
bool faultTypeExistOnContract = false;
for (int index = 0; index < targetOperation.Faults.Count; index++)
{
FaultDescription targetFault = targetOperation.Faults[index];
if (targetFault.DetailType == faultType)
{
string name = NamingHelper.TypeName(faultType) + TypeLoader.FaultSuffix;
string action = overridingAction ?? NamingHelper.GetMessageAction(targetOperation, false) + name;
if (targetFault.Action != action)
{
Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(action, "Fault Action", targetFault.Action, targetOperation.Name, targetOperation.DeclaringContract.Name)));
}
if (targetFault.Name != NamingHelper.XmlName(name))
{
Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(NamingHelper.XmlName(name), "Fault Name", targetFault.Name, targetOperation.Name, targetOperation.DeclaringContract.Name)));
}
if (targetFault.Namespace != targetOperation.DeclaringContract.Namespace)
{
Constraint.AddValidationError(context, new ValidationError(SR2.PropertyMismatch(targetOperation.DeclaringContract.Namespace, "Fault Namespace", targetFault.Namespace, targetOperation.Name, targetOperation.DeclaringContract.Name)));
}
if (targetFault.HasProtectionLevel)
{
Constraint.AddValidationError(context, new ValidationError(SR2.ProtectionLevelNotSupported(targetOperation.Name, targetOperation.DeclaringContract.Name)));
}
// TypeLoader guarantees that fault types are unique in the Faults collection.
faultTypeExistOnContract = true;
break;
}
}
// It is OK to have fewer fault types than defined on the contract.
// But we do not allow workflow to define more fault types than specified on the contract.
if (!faultTypeExistOnContract)
{
Constraint.AddValidationError(context, new ValidationError(SR2.FaultTypeMismatch(faultType.FullName, targetOperation.Name, targetOperation.DeclaringContract.Name)));
}
}
public override PolicyAssertionCollection GetFaultBindingAssertions(FaultDescription fault)
{
return(binding_assertions);
}
static void ImportFaultSoapAction(WsdlContractConversionContext contractContext, FaultDescription fault, FaultBinding wsdlFaultBinding)
{
string soapAction = SoapHelper.ReadSoapAction(wsdlFaultBinding.OperationBinding);
if (contractContext != null)
{
OperationFault wsdlOperationFault = contractContext.GetOperationFault(fault);
string wsaAction = WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(wsdlOperationFault);
if (wsaAction == null && soapAction != null)
{
fault.Action = soapAction;
}
//
}
else
{
//
}
}
private static CodeAttributeDeclaration CreateAttrDecl(OperationContractGenerationContext context, FaultDescription fault)
{
CodeTypeReference type = (fault.DetailType != null) context.Contract.ServiceContractGenerator.GetCodeTypeReference(fault.DetailType) fault.DetailTypeReference;
if ((type == null) (type == voidTypeReference))
{
return null;
}
CodeAttributeDeclaration declaration = new CodeAttributeDeclaration(context.ServiceContractGenerator.GetCodeTypeReference(typeof(FaultContractAttribute)));
declaration.Arguments.Add(new CodeAttributeArgument(new CodeTypeOfExpression(type)));
if (fault.Action != null)
{
declaration.Arguments.Add(new CodeAttributeArgument(Action, new CodePrimitiveExpression(fault.Action)));
}
if (fault.HasProtectionLevel)
{
declaration.Arguments.Add(new CodeAttributeArgument(ProtectionLevel, new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(ProtectionLevel)), fault.ProtectionLevel.ToString())));
}
if (!XmlName.IsNullOrEmpty(fault.ElementName))
{
declaration.Arguments.Add(new CodeAttributeArgument(Name, new CodePrimitiveExpression(fault.ElementName.EncodedName)));
}
if (fault.Namespace != context.Contract.Contract.Namespace)
{
declaration.Arguments.Add(new CodeAttributeArgument(Namespace, new CodePrimitiveExpression(fault.Namespace)));
}
return declaration;
}
void cacheSerializer(OperationDescription operation, FaultDescription fault)
{
// todo: should this include operation known types? If so, what happens if two ops have different known types but same fault?
_faultTypes.Add(fault.Action, fault.DetailType);
}
private static void ImportFaultSoapAction(WsdlContractConversionContext contractContext, FaultDescription fault, FaultBinding wsdlFaultBinding)
{
string str = SoapHelper.ReadSoapAction(wsdlFaultBinding.OperationBinding);
if (((contractContext != null) && (WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(contractContext.GetOperationFault(fault)) == null)) && (str != null))
{
fault.Action = str;
}
}
private static void ImportFaultSoapAction(WsdlContractConversionContext contractContext, FaultDescription fault, FaultBinding wsdlFaultBinding)
{
string soapAction = SoapHelper.ReadSoapAction(wsdlFaultBinding.OperationBinding);
if (contractContext != null)
{
OperationFault wsdlOperationFault = contractContext.GetOperationFault(fault);
string wsaAction = WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(wsdlOperationFault);
if (wsaAction == null && soapAction != null)
{
fault.Action = soapAction;
}
//CONSIDER, hsomu: If WS-Addressing action was found, we should verify that it is the same as the SOAP action
// (for the request message).
}
else
{
//CONSIDER, hsomu: verify SOAP action matches referenced contract.operation.message
}
}
private void ProcessContractOperations(ServiceEndpoint endpoint, bool isClient)
{
ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "ProcessServiceOperations");
try
{
ContractDescription contractDesc = endpoint.Contract;
foreach (OperationDescription oprDesc in contractDesc.Operations)
{
MessageDescription msgRequest = null;
MessageDescription msgResponse = null;
if (oprDesc.Messages != null)
{
foreach (MessageDescription msgDesc in oprDesc.Messages)
{
if (msgDesc.Direction == MessageDirection.Input)
{
msgRequest = msgDesc;
}
else if (msgDesc.Direction == MessageDirection.Output)
{
msgResponse = msgDesc;
}
}
}
// customize the service operation
try
{
if (!isClient)
{
this.OnContractServiceOperation(oprDesc, (msgRequest != null || msgResponse != null),
msgRequest, msgResponse);
}
else
{
this.OnContractClientOperation(oprDesc, (msgRequest != null || msgResponse != null),
msgRequest, msgResponse);
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
if (!isClient)
{
// Fault contracts
try
{
FaultDescription faultDesc = oprDesc.Faults.Find(WcfExceptionDetail.ACTION);
if (faultDesc == null)
{
faultDesc = new FaultDescription(WcfExceptionDetail.ACTION);
faultDesc.Namespace = WcfExceptionDetail.NS;
faultDesc.Name = WcfExceptionDetail.NAME;
faultDesc.DetailType = typeof(WcfExceptionDetail);
//oprDesc.Faults.Add(faultDesc);
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
}
}
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
}
