/// <summary>
/// Execute MQ with requestContext
/// </summary>
public object ExecuteMessage(IMessage dto, IRequest req)
{
req.Dto = appHost.ApplyRequestConverters(req, dto.Body);
if (appHost.ApplyMessageRequestFilters(req, req.Response, dto.Body))
{
return(req.Response.Dto);
}
var response = Execute(dto.Body, req);
var taskResponse = response as Task;
if (taskResponse != null)
{
response = taskResponse.GetResult();
}
response = appHost.ApplyResponseConverters(req, response);
if (appHost.ApplyMessageResponseFilters(req, req.Response, response))
{
response = req.Response.Dto;
}
req.Response.EndMqRequest();
return(response);
}
public override object CreateRequest(IRequest req, string operationName)
{
var requestType = GetOperationType(operationName);
AssertOperationExists(operationName, requestType);
using (Profiler.Current.Step("Deserialize Request"))
{
var requestDto = GetCustomRequestFromBinder(req, requestType)
?? (DeserializeHttpRequest(requestType, req, HandlerContentType)
?? requestType.CreateInstance());
return(appHost.ApplyRequestConverters(req, requestDto));
}
}
/// <summary>
/// Execute MQ with requestContext
/// </summary>
public object ExecuteMessage(IMessage dto, IRequest req)
{
req.Dto = appHost.ApplyRequestConverters(req, dto.Body);
if (appHost.ApplyMessageRequestFilters(req, req.Response, dto.Body))
{
return(req.Response.Dto);
}
var response = Execute(dto.Body, req);
response = ApplyResponseFilters(response, req);
req.Response.EndMqRequest();
return(response);
}
public object Execute(IRequest req, bool applyFilters)
{
try
{
req.SetInProcessRequest();
var restPath = HostContext.ServiceController.GetRestPathForRequest(req.Verb, req.PathInfo, req as IHttpRequest);
req.OperationName = restPath.RequestType.GetOperationName();
var task = RestHandler.CreateRequestAsync(req, restPath);
task.Wait();
var requestDto = task.Result;
req.Dto = requestDto;
if (applyFilters)
{
requestDto = AppHost.ApplyRequestConverters(req, requestDto);
AppHost.ApplyRequestFiltersAsync(req, req.Response, requestDto).Wait();
if (req.Response.IsClosed)
{
return(null);
}
}
var response = Execute(requestDto, req);
return(applyFilters
? ApplyResponseFilters(response, req)
: response);
}
finally
{
req.ReleaseIfInProcessRequest();
}
}
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);
}
}