/// <summary>
/// Takes a route/http contexts and attempts to parse, invoke, respond to an Rpc request
/// </summary>
/// <param name="context">Route context</param>
/// <returns>Task for async routing</returns>
public async Task RouteAsync(RouteContext context)
{
ILogger <RpcHttpRouter> logger = context.HttpContext.RequestServices.GetService <ILogger <RpcHttpRouter> >();
try
{
RpcPath?requestPath;
if (!context.HttpContext.Request.Path.HasValue)
{
requestPath = null;
}
else
{
if (!RpcPath.TryParse(context.HttpContext.Request.Path.Value.AsSpan(), out requestPath))
{
logger?.LogInformation($"Could not parse the path '{context.HttpContext.Request.Path.Value}' for the " +
$"request into an rpc path. Skipping rpc router middleware.");
return;
}
}
logger?.LogInformation($"Rpc request with route '{requestPath}' started.");
IRpcRequestHandler requestHandler = context.HttpContext.RequestServices.GetRequiredService <IRpcRequestHandler>();
var routeContext = DefaultRpcContext.Build(context.HttpContext.RequestServices, requestPath);
context.HttpContext.RequestServices.GetRequiredService <IRpcContextAccessor>().Value = routeContext;
Stream writableStream = this.BuildWritableResponseStream(context.HttpContext);
using (var requestBody = new MemoryStream())
{
await context.HttpContext.Request.Body.CopyToAsync(requestBody);
requestBody.Position = 0;
bool hasResponse = await requestHandler.HandleRequestAsync(requestBody, writableStream);
if (!hasResponse)
{
//No response required, but status code must be 204
context.HttpContext.Response.StatusCode = 204;
context.MarkAsHandled();
return;
}
}
context.MarkAsHandled();
logger?.LogInformation("Rpc request complete");
}
catch (Exception ex)
{
string errorMessage = "Unknown exception occurred when trying to process Rpc request. Marking route unhandled";
logger?.LogException(ex, errorMessage);
context.MarkAsHandled();
}
}
/// <summary>
/// Takes a route/http contexts and attempts to parse, invoke, respond to an Rpc request
/// </summary>
/// <param name="context">Route context</param>
/// <returns>Task for async routing</returns>
public async Task RouteAsync(RouteContext context)
{
try
{
RpcRoute route;
bool matchesRoute = this.parser.MatchesRpcRoute(this.configuration.Routes, context.HttpContext.Request.Path, out route);
if (!matchesRoute)
{
return;
}
this.logger?.LogInformation($"Rpc request route '{route.Name}' matched");
try
{
Stream contentStream = context.HttpContext.Request.Body;
string jsonString;
if (contentStream == null)
{
jsonString = null;
}
else
{
using (StreamReader streamReader = new StreamReader(contentStream))
{
jsonString = streamReader.ReadToEnd().Trim();
}
}
List <RpcRequest> requests = this.parser.ParseRequests(jsonString, this.configuration.JsonSerializerSettings);
this.logger?.LogInformation($"Processing {requests.Count} Rpc requests");
List <RpcResponse> responses = this.invoker.InvokeBatchRequest(requests, route, context.HttpContext.RequestServices, this.configuration.JsonSerializerSettings);
this.logger?.LogInformation($"Sending '{responses.Count}' Rpc responses");
await this.SetResponse(context, responses, this.configuration.JsonSerializerSettings);
context.MarkAsHandled();
this.logger?.LogInformation("Rpc request complete");
}
catch (RpcException ex)
{
context.MarkAsHandled();
this.logger?.LogException(ex, "Error occurred when proccessing Rpc request. Sending Rpc error response");
await this.SetErrorResponse(context, ex);
}
}
catch (Exception ex)
{
string errorMessage = "Unknown exception occurred when trying to process Rpc request. Marking route unhandled";
this.logger?.LogException(ex, errorMessage);
context.MarkAsHandled();
}
}
/// <summary>
/// Takes a route/http contexts and attempts to parse, invoke, respond to an Rpc request
/// </summary>
/// <param name="context">Route context</param>
/// <returns>Task for async routing</returns>
public async Task RouteAsync(RouteContext context)
{
ILogger <RpcRouter> logger = context.HttpContext.RequestServices.GetService <ILogger <RpcRouter> >();
try
{
RpcPath requestPath;
if (!context.HttpContext.Request.Path.HasValue)
{
requestPath = RpcPath.Default;
}
else
{
if (!RpcPath.TryParse(context.HttpContext.Request.Path.Value, out requestPath))
{
logger?.LogInformation($"Could not parse the path '{context.HttpContext.Request.Path.Value}' for the " +
$"request into an rpc path. Skipping rpc router middleware.");
return;
}
}
if (!requestPath.TryRemoveBasePath(this.routeProvider.BaseRequestPath, out requestPath))
{
logger?.LogTrace("Request did not match the base request path. Skipping rpc router.");
return;
}
HashSet <RpcPath> availableRoutes = this.routeProvider.GetRoutes();
if (!availableRoutes.Any())
{
logger?.LogDebug($"Request matched base request path but no routes.");
return;
}
logger?.LogInformation($"Rpc request route '{requestPath}' matched.");
Stream contentStream = context.HttpContext.Request.Body;
string jsonString;
if (contentStream == null)
{
jsonString = null;
}
else
{
StreamReader streamReader = new StreamReader(contentStream);
jsonString = streamReader.ReadToEnd().Trim();
}
var requestHandler = context.HttpContext.RequestServices.GetRequiredService <IRpcRequestHandler>();
var routeContext = DefaultRouteContext.FromHttpContext(context.HttpContext, this.routeProvider);
string responseJson = await requestHandler.HandleRequestAsync(requestPath, jsonString, routeContext);
if (responseJson == null)
{
//No response required
return;
}
context.HttpContext.Response.ContentType = "application/json";
bool responseSet = false;
string acceptEncoding = context.HttpContext.Request.Headers["Accept-Encoding"];
if (!string.IsNullOrWhiteSpace(acceptEncoding))
{
IRpcCompressor compressor = context.HttpContext.RequestServices.GetService <IRpcCompressor>();
if (compressor != null)
{
string[] encodings = acceptEncoding.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string encoding in encodings)
{
bool haveType = Enum.TryParse(encoding, true, out CompressionType compressionType);
if (!haveType)
{
continue;
}
context.HttpContext.Response.Headers.Add("Content-Encoding", new[] { encoding });
compressor.CompressText(context.HttpContext.Response.Body, responseJson, Encoding.UTF8, compressionType);
responseSet = true;
break;
}
}
}
if (!responseSet)
{
await context.HttpContext.Response.WriteAsync(responseJson);
}
context.MarkAsHandled();
logger?.LogInformation("Rpc request complete");
}
catch (Exception ex)
{
string errorMessage = "Unknown exception occurred when trying to process Rpc request. Marking route unhandled";
logger?.LogException(ex, errorMessage);
context.MarkAsHandled();
}
}
/// <summary>
/// Takes a route/http contexts and attempts to parse, invoke, respond to an Rpc request
/// </summary>
/// <param name="context">Route context</param>
/// <returns>Task for async routing</returns>
public async Task RouteAsync(RouteContext context)
{
try
{
RpcRoute route;
bool matchesRoute = this.parser.MatchesRpcRoute(this.routeProvider, context.HttpContext.Request.Path, out route);
if (!matchesRoute)
{
return;
}
this.logger?.LogInformation($"Rpc request route '{route.Name}' matched");
try
{
Stream contentStream = context.HttpContext.Request.Body;
string jsonString;
if (contentStream == null)
{
jsonString = null;
}
else
{
using (StreamReader streamReader = new StreamReader(contentStream))
{
jsonString = streamReader.ReadToEnd().Trim();
}
}
bool isBulkRequest;
List <RpcRequest> requests = this.parser.ParseRequests(jsonString, out isBulkRequest, this.serverConfig.Value.JsonSerializerSettings);
this.logger?.LogInformation($"Processing {requests.Count} Rpc requests");
int batchLimit = this.serverConfig.Value.BatchRequestLimit;
List <RpcResponse> responses;
if (batchLimit > 0 && requests.Count > batchLimit)
{
string batchLimitError = $"Request count exceeded batch request limit ({batchLimit}).";
responses = new List <RpcResponse>
{
new RpcResponse(null, new RpcError(RpcErrorCode.InvalidRequest, batchLimitError))
};
this.logger?.LogError(batchLimitError + " Returning error response.");
}
else
{
IRouteContext routeContext = DefaultRouteContext.FromHttpContext(context.HttpContext);
responses = await this.invoker.InvokeBatchRequestAsync(requests, route, routeContext, this.serverConfig.Value.JsonSerializerSettings);
}
this.logger?.LogInformation($"Sending '{responses.Count}' Rpc responses");
await this.SetResponse(context, responses, isBulkRequest, this.serverConfig.Value.JsonSerializerSettings);
context.MarkAsHandled();
this.logger?.LogInformation("Rpc request complete");
}
catch (RpcException ex)
{
context.MarkAsHandled();
this.logger?.LogException(ex, "Error occurred when proccessing Rpc request. Sending Rpc error response");
await this.SetErrorResponse(context, ex);
}
}
catch (Exception ex)
{
string errorMessage = "Unknown exception occurred when trying to process Rpc request. Marking route unhandled";
this.logger?.LogException(ex, errorMessage);
context.MarkAsHandled();
}
}
/// <summary>
/// Takes a route/http contexts and attempts to parse, invoke, respond to an Rpc request
/// </summary>
/// <param name="context">Route context</param>
/// <returns>Task for async routing</returns>
public async Task RouteAsync(RouteContext context)
{
ILogger <RpcHttpRouter> logger = context.HttpContext.RequestServices.GetService <ILogger <RpcHttpRouter> >();
try
{
RpcPath requestPath;
if (!context.HttpContext.Request.Path.HasValue)
{
requestPath = RpcPath.Default;
}
else
{
if (!RpcPath.TryParse(context.HttpContext.Request.Path.Value, out requestPath))
{
logger?.LogInformation($"Could not parse the path '{context.HttpContext.Request.Path.Value}' for the " +
$"request into an rpc path. Skipping rpc router middleware.");
return;
}
}
if (!requestPath.TryRemoveBasePath(this.routeProvider.BaseRequestPath, out requestPath))
{
logger?.LogTrace("Request did not match the base request path. Skipping rpc router.");
return;
}
logger?.LogInformation($"Rpc request with route '{requestPath}' started.");
string jsonString;
if (context.HttpContext.Request.Body == null)
{
jsonString = null;
}
else
{
using (StreamReader streamReader = new StreamReader(context.HttpContext.Request.Body, Encoding.UTF8,
detectEncodingFromByteOrderMarks: true,
bufferSize: 1024,
leaveOpen: true))
{
try
{
jsonString = await streamReader.ReadToEndAsync();
}
catch (TaskCanceledException ex)
{
throw new RpcCanceledRequestException("Cancelled while reading the request.", ex);
}
jsonString = jsonString.Trim();
}
}
IRpcRequestHandler requestHandler = context.HttpContext.RequestServices.GetRequiredService <IRpcRequestHandler>();
var routeContext = DefaultRouteContext.FromHttpContext(context.HttpContext, this.routeProvider);
string responseJson = await requestHandler.HandleRequestAsync(requestPath, jsonString, routeContext);
if (responseJson == null)
{
//No response required, but status code must be 204
context.HttpContext.Response.StatusCode = 204;
context.MarkAsHandled();
return;
}
context.HttpContext.Response.ContentType = "application/json";
bool responseSet = false;
string acceptEncoding = context.HttpContext.Request.Headers["Accept-Encoding"];
if (!string.IsNullOrWhiteSpace(acceptEncoding))
{
IStreamCompressor compressor = context.HttpContext.RequestServices.GetService <IStreamCompressor>();
if (compressor != null)
{
string[] encodings = acceptEncoding.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string encoding in encodings)
{
bool haveType = Enum.TryParse(encoding, true, out CompressionType compressionType);
if (!haveType)
{
continue;
}
context.HttpContext.Response.Headers.Add("Content-Encoding", new[] { encoding });
using (Stream responseStream = new MemoryStream(Encoding.UTF8.GetBytes(responseJson)))
{
compressor.Compress(responseStream, context.HttpContext.Response.Body, compressionType);
}
responseSet = true;
break;
}
}
}
if (!responseSet)
{
await context.HttpContext.Response.WriteAsync(responseJson);
}
context.MarkAsHandled();
logger?.LogInformation("Rpc request complete");
}
catch (Exception ex)
{
string errorMessage = "Unknown exception occurred when trying to process Rpc request. Marking route unhandled";
logger?.LogException(ex, errorMessage);
context.MarkAsHandled();
}
}