protected Message ExecuteMessage(Message requestMsg, EndpointAttributes endpointAttributes)
{
if ((EndpointAttributes.Soap11 & this.HandlerAttributes) == EndpointAttributes.Soap11)
{
EndpointHost.Config.AssertFeatures(Feature.Soap11);
}
else if ((EndpointAttributes.Soap12 & this.HandlerAttributes) == EndpointAttributes.Soap12)
{
EndpointHost.Config.AssertFeatures(Feature.Soap12);
}
string requestXml;
using (var reader = requestMsg.GetReaderAtBodyContents())
{
requestXml = reader.ReadOuterXml();
}
var requestType = GetRequestType(requestMsg, requestXml);
try
{
var request = DataContractDeserializer.Instance.Parse(requestXml, requestType);
IHttpRequest httpReq = null;
IHttpResponse httpRes = null;
var hasRequestFilters = EndpointHost.RequestFilters.Count > 0 ||
FilterAttributeCache.GetRequestFilterAttributes(request.GetType()).Any();
if (hasRequestFilters)
{
httpReq = HttpContext.Current != null
? new HttpRequestWrapper(requestType.Name, HttpContext.Current.Request)
: null;
httpRes = HttpContext.Current != null
? new HttpResponseWrapper(HttpContext.Current.Response)
: null;
}
if (hasRequestFilters && EndpointHost.ApplyRequestFilters(httpReq, httpRes, request))
{
return(EmptyResponse(requestMsg, requestType));
}
var response = ExecuteService(request, endpointAttributes, httpReq, httpRes);
var hasResponseFilters = EndpointHost.ResponseFilters.Count > 0 ||
FilterAttributeCache.GetResponseFilterAttributes(response.GetType()).Any();
if (hasResponseFilters && httpRes == null)
{
httpRes = HttpContext.Current != null
? new HttpResponseWrapper(HttpContext.Current.Response)
: null;
}
if (hasResponseFilters && EndpointHost.ApplyResponseFilters(httpReq, httpRes, response))
{
return(EmptyResponse(requestMsg, requestType));
}
return(requestMsg.Headers.Action == null
? Message.CreateMessage(requestMsg.Version, null, response)
: Message.CreateMessage(requestMsg.Version, requestType.Name + "Response", response));
}
catch (Exception ex)
{
throw new SerializationException("3) Error trying to deserialize requestType: "
+ requestType
+ ", xml body: " + requestXml, ex);
}
}
protected Message ExecuteMessage(Message message, RequestAttributes requestAttributes, IRequest httpReq, IResponse httpRes)
{
var soapFeature = requestAttributes.ToSoapFeature();
appHost.AssertFeatures(soapFeature);
if (httpReq == null)
{
httpReq = HostContext.GetCurrentRequest();
}
if (httpRes == null && httpReq != null)
{
httpRes = httpReq.Response;
}
if (httpReq == null)
{
throw new ArgumentNullException("httpReq");
}
if (httpRes == null)
{
throw new ArgumentNullException("httpRes");
}
httpReq.UseBufferedStream = true;
var requestMsg = message ?? GetRequestMessageFromStream(httpReq.InputStream);
var soapAction = httpReq.GetHeader(HttpHeaders.SOAPAction)
?? GetAction(requestMsg);
if (soapAction != null)
{
httpReq.OperationName = soapAction.Trim('"');
}
if (HostContext.ApplyCustomHandlerRequestFilters(httpReq, httpRes))
{
return(PrepareEmptyResponse(message, httpReq));
}
string requestXml = GetRequestXml(requestMsg);
var requestType = GetRequestType(requestMsg, requestXml);
httpReq.OperationName = requestType.GetOperationName();
if (!HostContext.Metadata.CanAccess(requestAttributes, soapFeature.ToFormat(), requestType.GetOperationName()))
{
throw HostContext.UnauthorizedAccess(requestAttributes);
}
try
{
var useXmlSerializerRequest = requestType.HasAttribute <XmlSerializerFormatAttribute>();
var request = appHost.ApplyRequestConverters(httpReq,
useXmlSerializerRequest
? XmlSerializableSerializer.Instance.DeserializeFromString(requestXml, requestType)
: Serialization.DataContractSerializer.Instance.DeserializeFromString(requestXml, requestType)
);
httpReq.Dto = request;
var requiresSoapMessage = request as IRequiresSoapMessage;
if (requiresSoapMessage != null)
{
requiresSoapMessage.Message = requestMsg;
}
httpReq.SetItem(Keywords.SoapMessage, requestMsg);
httpRes.ContentType = GetSoapContentType(httpReq.ContentType);
var hasRequestFilters = HostContext.GlobalRequestFilters.Count > 0 ||
FilterAttributeCache.GetRequestFilterAttributes(request.GetType()).Any();
if (hasRequestFilters && HostContext.ApplyRequestFilters(httpReq, httpRes, request))
{
return(EmptyResponse(requestMsg, requestType));
}
httpReq.RequestAttributes |= requestAttributes;
var response = ExecuteService(request, httpReq);
var taskResponse = response as Task;
if (taskResponse != null)
{
taskResponse.Wait();
response = Text.FastMember.TypeAccessor.Create(taskResponse.GetType())[taskResponse, "Result"];
}
response = appHost.ApplyResponseConverters(httpReq, response);
if (appHost.ApplyResponseFilters(httpReq, httpRes, response))
{
return(EmptyResponse(requestMsg, requestType));
}
var httpResult = response as IHttpResult;
if (httpResult != null)
{
response = httpResult.Response;
}
var noMsgAction = requestMsg.Headers.Action == null;
var responseMsg = CreateResponseMessage(response, requestMsg.Version, requestType, noMsgAction);
if (httpResult != null)
{
SetErrorStatusIfAny(httpReq.Response, responseMsg, httpResult.Status);
}
return(responseMsg);
}
catch (Exception ex)
{
if (httpReq.Dto != null)
{
HostContext.RaiseServiceException(httpReq, httpReq.Dto, ex);
}
else
{
HostContext.RaiseUncaughtException(httpReq, httpRes, httpReq.OperationName, ex);
}
throw new SerializationException("3) Error trying to deserialize requestType: "
+ requestType
+ ", xml body: " + requestXml, ex);
}
}
protected async Task ApplyRequestFiltersSingleAsync(IRequest req, IResponse res, object requestDto)
{
//Exec all RequestFilter attributes with Priority < 0
var attributes = FilterAttributeCache.GetRequestFilterAttributes(requestDto.GetType());
var i = 0;
for (; i < attributes.Length && attributes[i].Priority < 0; i++)
{
var attribute = attributes[i];
Container.AutoWire(attribute);
if (attribute is IHasRequestFilter filterSync)
{
filterSync.RequestFilter(req, res, requestDto);
}
else if (attribute is IHasRequestFilterAsync filterAsync)
{
await filterAsync.RequestFilterAsync(req, res, requestDto);
}
Release(attribute);
if (res.IsClosed)
{
return;
}
}
ExecTypedFilters(GlobalTypedRequestFilters, req, res, requestDto);
if (res.IsClosed)
{
return;
}
//Exec global filters
foreach (var requestFilter in GlobalRequestFiltersArray)
{
requestFilter(req, res, requestDto);
if (res.IsClosed)
{
return;
}
}
foreach (var requestFilter in GlobalRequestFiltersAsyncArray)
{
await requestFilter(req, res, requestDto);
if (res.IsClosed)
{
return;
}
}
//Exec remaining RequestFilter attributes with Priority >= 0
for (; i < attributes.Length && attributes[i].Priority >= 0; i++)
{
var attribute = attributes[i];
Container.AutoWire(attribute);
if (attribute is IHasRequestFilter filterSync)
{
filterSync.RequestFilter(req, res, requestDto);
}
else if (attribute is IHasRequestFilterAsync filterAsync)
{
await filterAsync.RequestFilterAsync(req, res, requestDto);
}
Release(attribute);
if (res.IsClosed)
{
return;
}
}
}
/// <summary>
/// Executes Service Response Filters
/// </summary>
protected async Task ApplyResponseFiltersSingleAsync(IRequest req, IResponse res, object response)
{
var attributes = req.Dto != null
? FilterAttributeCache.GetResponseFilterAttributes(req.Dto.GetType())
: null;
//Exec all ResponseFilter attributes with Priority < 0
var i = 0;
if (attributes != null)
{
for (; i < attributes.Length && attributes[i].Priority < 0; i++)
{
var attribute = attributes[i];
Container.AutoWire(attribute);
if (attribute is IHasResponseFilter filterSync)
{
filterSync.ResponseFilter(req, res, response);
}
else if (attribute is IHasResponseFilterAsync filterAsync)
{
await filterAsync.ResponseFilterAsync(req, res, response).ConfigAwait();
}
Release(attribute);
if (res.IsClosed)
{
return;
}
}
}
if (response != null)
{
if (GlobalTypedResponseFilters.Count > 0)
{
ExecTypedFilters(GlobalTypedResponseFilters, req, res, response);
if (res.IsClosed)
{
return;
}
}
if (GlobalTypedResponseFiltersAsync.Count > 0)
{
await ExecTypedFiltersAsync(GlobalTypedResponseFiltersAsync, req, res, response);
if (res.IsClosed)
{
return;
}
}
}
//Exec global filters
foreach (var responseFilter in GlobalResponseFiltersArray)
{
responseFilter(req, res, response);
if (res.IsClosed)
{
return;
}
}
foreach (var responseFilter in GlobalResponseFiltersAsyncArray)
{
await responseFilter(req, res, response).ConfigAwait();
if (res.IsClosed)
{
return;
}
}
//Exec remaining RequestFilter attributes with Priority >= 0
if (attributes != null)
{
for (; i < attributes.Length; i++)
{
var attribute = attributes[i];
Container.AutoWire(attribute);
if (attribute is IHasResponseFilter filterSync)
{
filterSync.ResponseFilter(req, res, response);
}
else if (attribute is IHasResponseFilterAsync filterAsync)
{
await filterAsync.ResponseFilterAsync(req, res, response).ConfigAwait();
}
Release(attribute);
if (res.IsClosed)
{
return;
}
}
}
}
/// <summary>
/// Applies the response filters. Returns whether or not the request has been handled
/// and no more processing should be done.
/// </summary>
/// <returns></returns>
public virtual bool ApplyResponseFilters(IRequest req, IResponse res, object response)
{
req.ThrowIfNull("req");
res.ThrowIfNull("res");
using (Profiler.Current.Step("Executing Response Filters"))
{
var responseDto = response.GetResponseDto();
var attributes = responseDto != null
? FilterAttributeCache.GetResponseFilterAttributes(responseDto.GetType())
: null;
//Exec all ResponseFilter attributes with Priority < 0
var i = 0;
if (attributes != null)
{
for (; i < attributes.Length && attributes[i].Priority < 0; i++)
{
var attribute = attributes[i];
Container.AutoWire(attribute);
attribute.ResponseFilter(req, res, response);
Release(attribute);
if (res.IsClosed)
{
return(res.IsClosed);
}
}
}
ExecTypedFilters(GlobalTypedResponseFilters, req, res, response);
if (res.IsClosed)
{
return(res.IsClosed);
}
//Exec global filters
foreach (var responseFilter in GlobalResponseFilters)
{
responseFilter(req, res, response);
if (res.IsClosed)
{
return(res.IsClosed);
}
}
//Exec remaining RequestFilter attributes with Priority >= 0
if (attributes != null)
{
for (; i < attributes.Length; i++)
{
var attribute = attributes[i];
Container.AutoWire(attribute);
attribute.ResponseFilter(req, res, response);
Release(attribute);
if (res.IsClosed)
{
return(res.IsClosed);
}
}
}
return(res.IsClosed);
}
}
/// <summary>
/// Applies the response filters. Returns whether or not the request has been handled
/// and no more processing should be done.
/// </summary>
/// <returns></returns>
public static bool ApplyResponseFilters(IHttpRequest httpReq, IHttpResponse httpRes, object response)
{
httpReq.ThrowIfNull("httpReq");
httpRes.ThrowIfNull("httpRes");
using (Profiler.Current.Step("Executing Response Filters"))
{
var responseDto = response.ToResponseDto();
var attributes = responseDto != null
? FilterAttributeCache.GetResponseFilterAttributes(responseDto.GetType())
: null;
//Exec all ResponseFilter attributes with Priority < 0
var i = 0;
if (attributes != null)
{
for (; i < attributes.Length && attributes[i].Priority < 0; i++)
{
var attribute = attributes[i];
ServiceManager.Container.AutoWire(attribute);
attribute.ResponseFilter(httpReq, httpRes, response);
if (AppHost != null) //tests
{
AppHost.Release(attribute);
}
if (httpRes.IsClosed)
{
return(httpRes.IsClosed);
}
}
}
//Exec global filters
foreach (var responseFilter in ResponseFilters)
{
responseFilter(httpReq, httpRes, response);
if (httpRes.IsClosed)
{
return(httpRes.IsClosed);
}
}
//Exec remaining RequestFilter attributes with Priority >= 0
if (attributes != null)
{
for (; i < attributes.Length; i++)
{
var attribute = attributes[i];
ServiceManager.Container.AutoWire(attribute);
attribute.ResponseFilter(httpReq, httpRes, response);
if (AppHost != null) //tests
{
AppHost.Release(attribute);
}
if (httpRes.IsClosed)
{
return(httpRes.IsClosed);
}
}
}
return(httpRes.IsClosed);
}
}
protected virtual bool ApplyResponseFiltersSingle(IRequest req, IResponse res, object response)
{
var responseDto = response.GetResponseDto();
var attributes = responseDto != null
? FilterAttributeCache.GetResponseFilterAttributes(responseDto.GetType())
: null;
//Exec all ResponseFilter attributes with Priority < 0
var i = 0;
if (attributes != null)
{
for (; i < attributes.Length && attributes[i].Priority < 0; i++)
{
var attribute = attributes[i];
Container.AutoWire(attribute);
attribute.ResponseFilter(req, res, response);
Release(attribute);
if (res.IsClosed)
{
return(res.IsClosed);
}
}
}
if (response != null)
{
ExecTypedFilters(GlobalTypedResponseFilters, req, res, response);
if (res.IsClosed)
{
return(res.IsClosed);
}
}
//Exec global filters
foreach (var responseFilter in GlobalResponseFilters)
{
responseFilter(req, res, response);
if (res.IsClosed)
{
return(res.IsClosed);
}
}
//Exec remaining RequestFilter attributes with Priority >= 0
if (attributes != null)
{
for (; i < attributes.Length; i++)
{
var attribute = attributes[i];
Container.AutoWire(attribute);
attribute.ResponseFilter(req, res, response);
Release(attribute);
if (res.IsClosed)
{
return(res.IsClosed);
}
}
}
return(res.IsClosed);
}
protected Message ExecuteMessage(Message requestMsg, EndpointAttributes endpointAttributes, IHttpRequest httpRequest, IHttpResponse httpResponse)
{
var soapFeatue = endpointAttributes.ToSoapFeature();
EndpointHost.Config.AssertFeatures(soapFeatue);
string requestXml;
using (var reader = requestMsg.GetReaderAtBodyContents())
{
requestXml = reader.ReadOuterXml();
}
var requestType = GetRequestType(requestMsg, requestXml);
if (!EndpointHost.Metadata.CanAccess(endpointAttributes, soapFeatue.ToFormat(), requestType.Name))
{
throw EndpointHost.Config.UnauthorizedAccess(endpointAttributes);
}
try
{
var request = DataContractDeserializer.Instance.Parse(requestXml, requestType);
var requiresSoapMessage = request as IRequiresSoapMessage;
if (requiresSoapMessage != null)
{
requiresSoapMessage.Message = requestMsg;
}
var httpReq = HttpContext.Current != null
? new HttpRequestWrapper(requestType.Name, HttpContext.Current.Request)
: httpRequest;
var httpRes = HttpContext.Current != null
? new HttpResponseWrapper(HttpContext.Current.Response)
: httpResponse;
if (EndpointHost.ApplyPreRequestFilters(httpReq, httpRes))
{
return(EmptyResponse(requestMsg, requestType));
}
var hasRequestFilters = EndpointHost.RequestFilters.Count > 0 ||
FilterAttributeCache.GetRequestFilterAttributes(request.GetType()).Any();
if (hasRequestFilters && EndpointHost.ApplyRequestFilters(httpReq, httpRes, request))
{
return(EmptyResponse(requestMsg, requestType));
}
var response = ExecuteService(request, endpointAttributes, httpReq, httpRes);
var hasResponseFilters = EndpointHost.ResponseFilters.Count > 0 ||
FilterAttributeCache.GetResponseFilterAttributes(response.GetType()).Any();
if (hasResponseFilters && EndpointHost.ApplyResponseFilters(httpReq, httpRes, response))
{
return(EmptyResponse(requestMsg, requestType));
}
var httpResult = response as IHttpResult;
if (httpResult != null)
{
response = httpResult.Response;
}
return(requestMsg.Headers.Action == null
? Message.CreateMessage(requestMsg.Version, null, response)
: Message.CreateMessage(requestMsg.Version, requestType.Name + "Response", response));
}
catch (Exception ex)
{
throw new SerializationException("3) Error trying to deserialize requestType: "
+ requestType
+ ", xml body: " + requestXml, ex);
}
}
protected Message ExecuteMessage(Message message, EndpointAttributes endpointAttributes, IHttpRequest httpRequest, IHttpResponse httpResponse)
{
var soapFeature = endpointAttributes.ToSoapFeature();
EndpointHost.Config.AssertFeatures(soapFeature);
var httpReq = HttpContext.Current != null && httpRequest == null
? new HttpRequestWrapper(HttpContext.Current.Request)
: httpRequest;
var httpRes = HttpContext.Current != null && httpResponse == null
? new HttpResponseWrapper(HttpContext.Current.Response)
: httpResponse;
if (httpReq == null)
{
throw new ArgumentNullException("httpRequest");
}
if (httpRes == null)
{
throw new ArgumentNullException("httpResponse");
}
if (EndpointHost.ApplyPreRequestFilters(httpReq, httpRes))
{
return(PrepareEmptyResponse(message, httpReq));
}
var requestMsg = message ?? GetRequestMessageFromStream(httpReq.InputStream);
string requestXml = GetRequestXml(requestMsg);
var requestType = GetRequestType(requestMsg, requestXml);
if (!EndpointHost.Metadata.CanAccess(endpointAttributes, soapFeature.ToFormat(), requestType.Name))
{
throw EndpointHost.Config.UnauthorizedAccess(endpointAttributes);
}
try
{
var useXmlSerializerRequest = requestType.HasAttribute <XmlSerializerFormatAttribute>();
var request = useXmlSerializerRequest
? XmlSerializableDeserializer.Instance.Parse(requestXml, requestType)
: DataContractDeserializer.Instance.Parse(requestXml, requestType);
var requiresSoapMessage = request as IRequiresSoapMessage;
if (requiresSoapMessage != null)
{
requiresSoapMessage.Message = requestMsg;
}
httpReq.OperationName = requestType.Name;
httpReq.SetItem("SoapMessage", requestMsg);
var hasRequestFilters = EndpointHost.RequestFilters.Count > 0 ||
FilterAttributeCache.GetRequestFilterAttributes(request.GetType()).Any();
if (hasRequestFilters && EndpointHost.ApplyRequestFilters(httpReq, httpRes, request))
{
return(EmptyResponse(requestMsg, requestType));
}
var response = ExecuteService(request, endpointAttributes, httpReq, httpRes);
var hasResponseFilters = EndpointHost.ResponseFilters.Count > 0 ||
FilterAttributeCache.GetResponseFilterAttributes(response.GetType()).Any();
if (hasResponseFilters && EndpointHost.ApplyResponseFilters(httpReq, httpRes, response))
{
return(EmptyResponse(requestMsg, requestType));
}
var httpResult = response as IHttpResult;
if (httpResult != null)
{
response = httpResult.Response;
}
var useXmlSerializerResponse = response.GetType().HasAttribute <XmlSerializerFormatAttribute>();
if (useXmlSerializerResponse)
{
return(requestMsg.Headers.Action == null
? Message.CreateMessage(requestMsg.Version, null, response, new XmlSerializerWrapper(response.GetType()))
: Message.CreateMessage(requestMsg.Version, requestType.Name + "Response", response, new XmlSerializerWrapper(response.GetType())));
}
return(requestMsg.Headers.Action == null
? Message.CreateMessage(requestMsg.Version, null, response)
: Message.CreateMessage(requestMsg.Version, requestType.Name + "Response", response));
}
catch (Exception ex)
{
throw new SerializationException("3) Error trying to deserialize requestType: "
+ requestType
+ ", xml body: " + requestXml, ex);
}
}
protected async Task <Message> ExecuteMessage(Message message, RequestAttributes requestAttributes, IRequest httpReq, IResponse httpRes)
{
var soapFeature = requestAttributes.ToSoapFeature();
appHost.AssertFeatures(soapFeature);
if (httpReq == null)
{
httpReq = HostContext.GetCurrentRequest();
}
if (httpRes == null && httpReq != null)
{
httpRes = httpReq.Response;
}
if (httpReq == null)
{
throw new ArgumentNullException(nameof(httpReq));
}
if (httpRes == null)
{
throw new ArgumentNullException(nameof(httpRes));
}
httpReq.UseBufferedStream = true;
var requestMsg = message ?? GetRequestMessageFromStream(httpReq.InputStream);
var soapAction = httpReq.GetHeader(HttpHeaders.SOAPAction)
?? GetAction(requestMsg);
if (soapAction != null)
{
httpReq.OperationName = soapAction.Trim('"');
}
if (HostContext.ApplyCustomHandlerRequestFilters(httpReq, httpRes))
{
return(PrepareEmptyResponse(message, httpReq));
}
string requestXml = GetRequestXml(requestMsg);
var requestType = GetRequestType(requestMsg, requestXml);
httpReq.OperationName = requestType.GetOperationName();
if (!HostContext.Metadata.CanAccess(requestAttributes, soapFeature.ToFormat(), requestType.GetOperationName()))
{
throw HostContext.UnauthorizedAccess(requestAttributes);
}
try
{
var useXmlSerializerRequest = requestType.HasAttribute <XmlSerializerFormatAttribute>();
var request = appHost.ApplyRequestConvertersAsync(httpReq,
useXmlSerializerRequest
? XmlSerializableSerializer.Instance.DeserializeFromString(requestXml, requestType)
: Serialization.DataContractSerializer.Instance.DeserializeFromString(requestXml, requestType)
).Result;
httpReq.Dto = request;
if (request is IRequiresSoapMessage requiresSoapMessage)
{
requiresSoapMessage.Message = requestMsg;
}
httpReq.SetItem(Keywords.SoapMessage, requestMsg);
httpRes.ContentType = GetSoapContentType(httpReq.ContentType);
var hasRequestFilters = HostContext.AppHost.GlobalRequestFiltersArray.Length > 0 ||
HostContext.AppHost.GlobalRequestFiltersAsyncArray.Length > 0 ||
FilterAttributeCache.GetRequestFilterAttributes(request.GetType()).Any();
if (hasRequestFilters)
{
HostContext.ApplyRequestFiltersAsync(httpReq, httpRes, request).Wait();
if (httpRes.IsClosed)
{
return(EmptyResponse(requestMsg, requestType));
}
}
httpReq.RequestAttributes |= requestAttributes;
var response = await GetResponseAsync(httpReq, request);
response = appHost.ApplyResponseConvertersAsync(httpReq, response).Result;
appHost.ApplyResponseFiltersAsync(httpReq, httpRes, response).Wait();
if (httpRes.IsClosed)
{
return(EmptyResponse(requestMsg, requestType));
}
var httpResult = response as IHttpResult;
if (httpResult != null)
{
response = httpResult.Response;
}
var noMsgAction = requestMsg.Headers.Action == null;
var responseMsg = CreateResponseMessage(response, requestMsg.Version, requestType, noMsgAction);
if (httpResult != null)
{
SetErrorStatusIfAny(httpReq.Response, responseMsg, httpResult.Status);
}
return(responseMsg);
}
catch (Exception ex)
{
try
{
if (httpReq.Dto != null)
{
HostContext.RaiseServiceException(httpReq, httpReq.Dto, ex).Wait();
}
else
{
HostContext.RaiseUncaughtException(httpReq, httpRes, httpReq.OperationName, ex).Wait();
}
throw new SerializationException($"Error trying to deserialize requestType: {requestType}, xml body: {requestXml}", ex);
}
catch (Exception useEx)
{
var responseType = HostContext.Metadata.GetOperation(requestType).ResponseType
?? typeof(ErrorResponse);
var responseStatus = useEx.ToResponseStatus();
var response = responseType.CreateInstance();
var setter = TypeProperties.Get(responseType).GetPublicSetter(nameof(IHasResponseStatus.ResponseStatus));
setter(response, responseStatus);
var noMsgAction = requestMsg.Headers.Action == null;
var responseMsg = CreateResponseMessage(response, requestMsg.Version, requestType, noMsgAction);
SetErrorStatusIfAny(httpReq.Response, responseMsg, useEx.ToStatusCode());
return(responseMsg);
}
}
}
protected Message ExecuteMessage(Message message, RequestAttributes requestAttributes, IRequest httpRequest, IResponse httpResponse)
{
var soapFeature = requestAttributes.ToSoapFeature();
HostContext.AppHost.AssertFeatures(soapFeature);
var httpReq = HttpContext.Current != null && httpRequest == null
? HttpContext.Current.ToRequest()
: httpRequest;
var httpRes = HttpContext.Current != null && httpResponse == null
? httpReq.Response
: httpResponse;
if (httpReq == null)
{
throw new ArgumentNullException("httpRequest");
}
if (httpRes == null)
{
throw new ArgumentNullException("httpResponse");
}
if (HostContext.ApplyPreRequestFilters(httpReq, httpRes))
{
return(PrepareEmptyResponse(message, httpReq));
}
var requestMsg = message ?? GetRequestMessageFromStream(httpReq.InputStream);
string requestXml = GetRequestXml(requestMsg);
var requestType = GetRequestType(requestMsg, requestXml);
if (!HostContext.Metadata.CanAccess(requestAttributes, soapFeature.ToFormat(), requestType.GetOperationName()))
{
throw HostContext.UnauthorizedAccess(requestAttributes);
}
try
{
var useXmlSerializerRequest = requestType.HasAttribute <XmlSerializerFormatAttribute>();
var request = useXmlSerializerRequest
? XmlSerializableSerializer.Instance.DeserializeFromString(requestXml, requestType)
: Serialization.DataContractSerializer.Instance.DeserializeFromString(requestXml, requestType);
var requiresSoapMessage = request as IRequiresSoapMessage;
if (requiresSoapMessage != null)
{
requiresSoapMessage.Message = requestMsg;
}
httpReq.OperationName = requestType.GetOperationName();
httpReq.SetItem("SoapMessage", requestMsg);
var hasRequestFilters = HostContext.GlobalRequestFilters.Count > 0 ||
FilterAttributeCache.GetRequestFilterAttributes(request.GetType()).Any();
if (hasRequestFilters && HostContext.ApplyRequestFilters(httpReq, httpRes, request))
{
return(EmptyResponse(requestMsg, requestType));
}
httpReq.RequestAttributes |= requestAttributes;
var response = ExecuteService(request, httpReq);
var taskResponse = response as Task;
if (taskResponse != null)
{
taskResponse.Wait();
response = TypeAccessor.Create(taskResponse.GetType())[taskResponse, "Result"];
}
var hasResponseFilters = HostContext.GlobalResponseFilters.Count > 0 ||
FilterAttributeCache.GetResponseFilterAttributes(response.GetType()).Any();
if (hasResponseFilters && HostContext.ApplyResponseFilters(httpReq, httpRes, response))
{
return(EmptyResponse(requestMsg, requestType));
}
var httpResult = response as IHttpResult;
if (httpResult != null)
{
response = httpResult.Response;
}
var useXmlSerializerResponse = response.GetType().HasAttribute <XmlSerializerFormatAttribute>();
if (useXmlSerializerResponse)
{
return(requestMsg.Headers.Action == null
? Message.CreateMessage(requestMsg.Version, null, response, new XmlSerializerWrapper(response.GetType()))
: Message.CreateMessage(requestMsg.Version, requestType.GetOperationName() + "Response", response, new XmlSerializerWrapper(response.GetType())));
}
return(requestMsg.Headers.Action == null
? Message.CreateMessage(requestMsg.Version, null, response)
: Message.CreateMessage(requestMsg.Version, requestType.GetOperationName() + "Response", response));
}
catch (Exception ex)
{
throw new SerializationException("3) Error trying to deserialize requestType: "
+ requestType
+ ", xml body: " + requestXml, ex);
}
}
