private async Task <HttpServiceRequest> ParseRequest(HttpListenerContext context)
{
var request = await _deserializationTime.Time(async() =>
{
using (var streamReader = new StreamReader(context.Request.InputStream))
{
var json = await streamReader.ReadToEndAsync();
return(JsonConvert.DeserializeObject <HttpServiceRequest>(json, JsonSettings));
}
});
request.TracingData = request.TracingData ?? new TracingData();
request.TracingData.RequestID = request.TracingData.RequestID ?? Guid.NewGuid().ToString("N");
TracingContext.SetRequestID(request.TracingData.RequestID);
TracingContext.SetSpan(request.TracingData.SpanID, request.TracingData.ParentSpanID);
return(request);
}
private async Task <HttpServiceRequest> ParseRequest(HttpListenerContext context)
{
HttpServiceRequest request;
using (var streamReader = new StreamReader(context.Request.InputStream))
{
var json = await streamReader.ReadToEndAsync();
request = JsonConvert.DeserializeObject <HttpServiceRequest>(json, JsonSettings);
}
request.TracingData = request.TracingData ?? new TracingData();
request.TracingData.RequestID = request.TracingData.RequestID ?? Guid.NewGuid().ToString("N");
TracingContext.SetRequestID(request.TracingData.RequestID);
TracingContext.SetSpan(request.TracingData.SpanID, request.TracingData.ParentSpanID);
TracingContext.SpanStartTime = request.TracingData.SpanStartTime;
TracingContext.AbandonRequestBy = request.TracingData.AbandonRequestBy;
return(request);
}
private async Task HandleRequest(HttpListenerContext context)
{
RequestTimings.ClearCurrentTimings();
using (context.Response)
{
var sw = Stopwatch.StartNew();
// Special endpoints should not be logged/measured/traced like regular endpoints
if (await TryHandleSpecialEndpoints(context))
{
return;
}
// Regular endpoint handling
using (_activeRequestsCounter.NewContext("Request"))
{
RequestTimings.GetOrCreate(); // initialize request timing context
string methodName = null;
// Initialize with empty object for protocol backwards-compatibility.
var requestData = new HttpServiceRequest {
TracingData = new TracingData()
};
object[] argumentsWithDefaults = null;
ServiceMethod serviceMethod = null;
ServiceCallEvent callEvent = _serverRequestPublisher.GetNewCallEvent();
try
{
try
{
ValidateRequest(context);
await CheckSecureConnection(context);
requestData = await ParseRequest(context);
//-----------------------------------------------------------------------------------------
// Don't move TracingContext writes main flow, IT have to be here, to avoid side changes
//-----------------------------------------------------------------------------------------
TracingContext.SetRequestID(requestData.TracingData.RequestID);
TracingContext.SpanStartTime = requestData.TracingData.SpanStartTime;
TracingContext.AbandonRequestBy = requestData.TracingData.AbandonRequestBy;
TracingContext.SetSpan(null, requestData.TracingData.SpanID ?? Guid.NewGuid().ToString("N"));
SetCallEventRequestData(callEvent, requestData);
TracingContext.SetOverrides(requestData.Overrides);
serviceMethod = ServiceEndPointDefinition.Resolve(requestData.Target);
callEvent.CalledServiceName = serviceMethod.GrainInterfaceType.Name;
methodName = serviceMethod.ServiceInterfaceMethod.Name;
var arguments = requestData.Target.IsWeaklyTyped ? GetParametersByName(serviceMethod, requestData.Arguments) : requestData.Arguments.Values.Cast <object>().ToArray();
argumentsWithDefaults = GetConvertedAndDefaultArguments(serviceMethod.ServiceInterfaceMethod, arguments);
}
catch (Exception e)
{
callEvent.Exception = e;
if (e is RequestException)
{
throw;
}
throw new RequestException("Invalid request", e);
}
RejectRequestIfLateOrOverloaded();
var responseJson = await GetResponse(context, serviceMethod, requestData, argumentsWithDefaults);
if (await TryWriteResponse(context, responseJson, serviceCallEvent: callEvent))
{
callEvent.ErrCode = 0;
_successCounter.Increment();
}
else
{
_failureCounter.Increment();
}
}
catch (Exception e)
{
callEvent.Exception = callEvent.Exception ?? e;
_failureCounter.Increment();
Exception ex = GetRelevantException(e);
string json = _serializationTime.Time(() => ExceptionSerializer.Serialize(ex));
await TryWriteResponse(context, json, GetExceptionStatusCode(ex), serviceCallEvent : callEvent);
}
finally
{
sw.Stop();
callEvent.ActualTotalTime = sw.Elapsed.TotalMilliseconds;
_roundtripTime.Record((long)(sw.Elapsed.TotalMilliseconds * 1000000), TimeUnit.Nanoseconds);
if (methodName != null)
{
_endpointContext.Timer(methodName, Unit.Requests).Record((long)(sw.Elapsed.TotalMilliseconds * 1000000), TimeUnit.Nanoseconds);
}
_serverRequestPublisher.TryPublish(callEvent, argumentsWithDefaults, serviceMethod);
}
}
}
}