public void StartAsyncWork()
{
_executedSynchronously = false;
_startTime = DateTime.Now;
try
{
Task task = _endpointHandler.ProcessRequestAsync(_httpRequest, _httpResponse, OperationName);
task.ContinueWith(t =>
{
if (t.Exception != null)
{
Log.Error("Error happened in async service execution!", t.Exception.InnerException ?? t.Exception,
new Dictionary <string, string>()
{
{ "ErrorCode", "FXD300079" }
});
}
PostWorkItemExecutionCallbackSafe();
});
}
catch (Exception ex)
{
try
{
var operation = EndpointHost.MetadataMap[ServicePath].OperationNameMap[OperationName];
var response = ErrorUtils.CreateFrameworkErrorResponse(_httpRequest, ex, operation.ResponseType);
_httpResponse.WriteToResponse(_httpRequest, response);
}
catch (Exception ex1)
{
Log.Error("Error happened when writing framework error response!", ex1, new Dictionary <string, string>()
{
{ "ErrorCode", "FXD300082" }
});
}
PostWorkItemExecutionCallbackSafe();
}
}
public virtual Task ProcessRequestAsync(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
TaskCompletionSource <object> tcs = new TaskCompletionSource <object>();
try
{
object requestObject = null;
if (PreProcessRequestAsync(httpReq, httpRes, operationName, out requestObject))
{
tcs.TrySetResult(null);
return(tcs.Task);
}
Task task = GetResponse(httpReq, httpRes, requestObject) as Task;
string identity = EndpointHost.Config.MetadataMap[httpReq.ServicePath].GetOperationByOpName(httpReq.OperationName).Key;
return(task.ContinueWith(t =>
{
try
{
object response = null;
if (t.Exception != null)
{
var ex = t.Exception.InnerException ?? t.Exception;
if (httpRes != null && httpRes.ExecutionResult != null)
{
httpRes.ExecutionResult.ExceptionCaught = ex;
}
Type responseType = EndpointHost.MetadataMap[ServicePath].GetResponseTypeByOpName(operationName);
response = ErrorUtils.CreateServiceErrorResponse(httpReq, ex, responseType);
httpRes.WriteToResponse(httpReq, response);
return;
}
response = ((Task <object>)t).Result;
if (PostProcessRequestAsync(httpReq, httpRes, operationName, response))
{
return;
}
httpRes.WriteToResponse(httpReq, response);
}
catch (Exception ex)
{
if (httpRes != null && httpRes.ExecutionResult != null)
{
httpRes.ExecutionResult.ExceptionCaught = ex;
}
throw;
}
finally
{
if (EndpointHost.PostResponseFilters.Count > 0)
{
EndpointHost.ApplyPostResponseFilters(new PostResponseFilterArgs()
{
ExecutionResult = httpRes.ExecutionResult,
ServicePath = httpReq.ServicePath,
OperationName = httpReq.OperationName,
RequestDeserializeTimeInMilliseconds = httpReq.DeserializationTimeInMillis,
ResponseSerializeTimeInMilliseconds = httpRes.SerializationTimeInMillis
});
}
}
}));
}
catch (Exception ex)
{
try
{
Type responseType = EndpointHost.MetadataMap[ServicePath].GetResponseTypeByOpName(operationName);
object response = ErrorUtils.CreateFrameworkErrorResponse(httpReq, ex, responseType);
httpRes.WriteToResponse(httpReq, response);
tcs.TrySetResult(null);
}
catch (Exception ex1)
{
tcs.TrySetException(ex1);
}
return(tcs.Task);
}
finally
{
HostContext.Instance.EndRequest();
}
}
public static void WriteErrorToResponse(this IHttpResponse httpRes, IHttpRequest httpReq,
string contentType, Exception ex, bool isCritical, string errorCode)
{
// Mark exception was thrown
if (httpRes.ExecutionResult != null)
{
if (httpReq.RequestObject == null)
httpRes.ExecutionResult.ValidationExceptionThrown = true;
else
httpRes.ExecutionResult.FrameworkExceptionThrown = true;
}
string operationName = httpReq.OperationName;
var responseType = operationName == null ? null : EndpointHost.Config.MetadataMap[httpReq.ServicePath].GetResponseTypeByOpName(operationName);
var errorResponseDto = ErrorUtils.CreateFrameworkErrorResponse(httpReq, ex, responseType, isCritical, errorCode);
if (httpRes.ContentType == null || httpRes.ContentType == ContentType.Html)
{
httpRes.ContentType = contentType;
}
if (EndpointHost.Config.AppendUtf8CharsetOnContentTypes.Contains(contentType))
{
httpRes.ContentType += ContentType.Utf8Suffix;
}
AddRequestInfoToResponseStatus(httpReq, errorResponseDto as IHasResponseStatus);
if (errorResponseDto is GenericErrorResponseType)
{
// With no response type specified,
// AntServiceStack C# client should throw WebProtocolException with a generic error response dto,
// We use http status code here to trigger client side WebServiceException.
httpRes.StatusCode = ex.ToStatusCode();
}
var serializationCtx = new SerializationContext(contentType);
var serializer = EndpointHost.AppHost.ContentTypeFilters.GetResponseSerializer(contentType);
if (serializer != null)
{
try
{
serializer(serializationCtx, errorResponseDto, httpRes);
}
catch (Exception)
{
throw;
}
finally
{
//httpRes.SerializationTimeInMillis = serializeTransaction.Transaction.DurationInMillis;
}
}
// Record error response size
if (httpRes.ExecutionResult != null)
{
httpRes.ExecutionResult.ResponseSize = httpRes.OutputStream.Length;
}
// outer caller will close the response
//httpRes.EndHttpHandlerRequest(skipHeaders: true);
}