/// <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)
{
if (!context.HttpContext.WebSockets.IsWebSocketRequest)
{
return;
}
ILogger <RpcWebSocketRouter> logger = context.HttpContext.RequestServices.GetService <ILogger <RpcWebSocketRouter> >();
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 web socket request is attempting to open.");
var scopeFactory = context.HttpContext.RequestServices.GetRequiredService <IServiceScopeFactory>();
using (WebSocket socket = await context.HttpContext.WebSockets.AcceptWebSocketAsync())
{
while (socket.State == WebSocketState.Open)
{
var buffer = new ArraySegment <byte>(new byte[1_000_000]);
/// <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)
{
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();
}
}
