private static async Task ReplyDocument(HttpContext http, string html, HttpStatusCode code)
{
MiddlewareCommon.SetStatusCode(http, code);
MiddlewareCommon.AddHeaderTextHtml(http);
MiddlewareCommon.AddHeaderPreventCaching(http);
await MiddlewareCommon.WriteUtf8Buffer(http, html);
}
// ReSharper disable once UnusedMethodReturnValue.Local
private bool TryGetDocument(HttpContext http, [NotNullWhen(true)] out Document?document)
{
document = default;
return(MiddlewareCommon.TryGetParameter(http.Request.Query, "doc", out var text) &&
Guid.TryParseExact(text, GlobalConstants.GuidFormat, out var documentId) &&
MiddlewareCommon.TryFindConnection(_app, http, out var connection) &&
connection.TryGetDocument(documentId, out document));
}
private async Task SendLibrary(HttpContext http)
{
#if DEBUG
MiddlewareCommon.AddHeaderPreventCaching(http);
#else
MiddlewareCommon.AddHeaderNeverExpires(http);
#endif
MiddlewareCommon.AddHeaderJSON(http);
await MiddlewareCommon.WriteBuffer(http, _library);
}
public bool TryGetSession([NotNullWhen(true)] out Session?session)
{
if (MiddlewareCommon.TryFindConnection(Application, Http, out var connection))
{
session = connection.Session;
return(true);
}
session = default;
return(false);
}
private static async Task ReplyStatusCodeError(Application app, HttpContext http, StatusCodeException status, LaraOptions options)
{
if (app.ErrorPages.TryGetPage(status.StatusCode, out var page))
{
await page.Run(app, http, options);
}
else
{
await MiddlewareCommon.SendStatusReply(http, status.StatusCode, status.Message);
}
}
public async Task Invoke(HttpContext http)
{
try
{
await TryInvoke(http);
}
catch (StatusCodeException e)
{
var text = $"HTTP error {(int)e.StatusCode} '{e.StatusCode}': {e.Message}";
await MiddlewareCommon.SendStatusReply(http, e.StatusCode, text);
}
}
internal static async Task <Task> RunEventHandler(PostEventContext post)
{
if (!await MiddlewareCommon.RunHandler(post.Http,
() => NotifyEventHandler(post)))
{
return(Task.CompletedTask);
}
var document = post.GetDocument();
var queue = document.FlushQueue();
return(await SendReply(post, queue));
}
internal static Connection GetConnection(Application app, HttpContext http)
{
Connection connection = null;
MiddlewareCommon.TryFindConnection(app, http, out connection);
if (connection == null)
{
connection = CreateConnection(app, http);
}
return(connection);
}
/// <summary>
/// Invokes this middleware
/// </summary>
/// <param name="context">The HttpContext</param>
/// <returns>Task</returns>
public Task Invoke(HttpContext context)
{
context = context ?? throw new ArgumentNullException(nameof(context));
var remote = context.Connection.RemoteIpAddress;
if (IPAddress.IsLoopback(remote))
{
return(_next.Invoke(context));
}
var msg = $"Forbidden request from {remote}";
_logger.LogInformation(msg);
return(MiddlewareCommon.SendStatusReply(context, HttpStatusCode.Forbidden, Resources.Http403));
}
private static async Task ProcessRequest(PostEventContext context)
{
if (MiddlewareCommon.TryFindConnection(context.Application, context.Http, out var connection) &&
context.Parameters != null &&
connection.TryGetDocument(context.Parameters.DocumentId, out var document))
{
context.Connection = connection;
context.Document = document;
await ProcessRequestDocument(context);
}
else
{
await SendEvent(context, EventResultType.NoSession);
}
}
public static bool TryParse(IQueryCollection query, [NotNullWhen(true)] out DiscardParameters?parameters)
{
if (MiddlewareCommon.TryGetParameter(query, "doc", out var documentText) &&
Guid.TryParseExact(documentText, GlobalConstants.GuidFormat, out var documentId))
{
parameters = new DiscardParameters
{
DocumentId = documentId,
};
return(true);
}
parameters = default;
return(false);
}
internal override async Task <bool> ProcessRequest(HttpContext http)
{
if (http.Request.Method != "POST" || http.Request.Path != "/_discard" ||
!DiscardParameters.TryParse(http, out var parameters) ||
!MiddlewareCommon.TryFindConnection(_app, http, out var connection))
{
return(false);
}
await Task.Delay(DiscardDelay);
await connection.Discard(parameters.DocumentId);
await _app.ClearEmptyConnection(connection);
return(true);
}
internal static async Task ProcessAjaxRequest(Application app, HttpContext http)
{
if (EventParameters.TryParse(http.Request.Query, out var parameters))
{
await parameters.ReadAjaxMessage(http);
var post = new PostEventContext(app, http)
{
Parameters = parameters
};
await ProcessRequest(post);
}
else
{
await MiddlewareCommon.SendStatusReply(http, HttpStatusCode.BadRequest, Resources.BadRequest);
}
}
public async Task Run(Application app, HttpContext http, LaraOptions options)
{
var context = new WebServiceContext(app, http)
{
RequestBody = await MiddlewareCommon.ReadBody(http).ConfigureAwait(false)
};
var handler = Factory();
var data = Array.Empty <byte>();
if (await MiddlewareCommon.RunHandler(http, async() =>
{
data = await handler.Execute();
}).ConfigureAwait(false))
{
await SendReply(context, data);
}
}
public static bool TryParse(IQueryCollection query, [NotNullWhen(true)] out EventParameters?parameters)
{
if (MiddlewareCommon.TryGetParameter(query, "doc", out var documentText) &&
MiddlewareCommon.TryGetParameter(query, "el", out var elementId) &&
MiddlewareCommon.TryGetParameter(query, "ev", out var eventName) &&
MiddlewareCommon.TryGetParameter(query, "seq", out var sequence) &&
long.TryParse(sequence, NumberStyles.Any, CultureInfo.InvariantCulture, out var eventNumber) &&
Guid.TryParseExact(documentText, GlobalConstants.GuidFormat, out var documentId))
{
parameters = new EventParameters
{
DocumentId = documentId,
ElementId = elementId,
EventName = eventName,
EventNumber = eventNumber
};
return(true);
}
parameters = default;
return(false);
}
private static async Task ProcessWebSocketEvent(Application app, HttpContext http)
{
var socket = await http.WebSockets.AcceptWebSocketAsync();
var result = await MiddlewareCommon.ReadWebSocketMessage <SocketEventParameters>(socket, MaxSizeBytes);
var context = new PostEventContext(app, http)
{
Http = http,
Socket = socket,
Parameters = result.Item2
};
if (result.Item1)
{
await ProcessRequest(context);
}
else
{
await context.Socket.CloseAsync(WebSocketCloseStatus.InvalidPayloadData,
"Bad request", CancellationToken.None);
}
}
internal static Connection GetConnection(Application app, HttpContext http)
{
return(MiddlewareCommon.TryFindConnection(app, http, out var connection) ? connection : CreateConnection(app, http));
}
private static async Task SendAjaxReply(HttpContext http, string json)
{
MiddlewareCommon.AddHeaderJSON(http);
await MiddlewareCommon.WriteUtf8Buffer(http, json);
}
private async Task SendReply(WebServiceContext context, byte[] data)
{
WebServicePublished.SendHeader(context, ContentType);
await MiddlewareCommon.WriteBuffer(context.Http, data);
}
private async Task SendReply(WebServiceContext context, string data)
{
SendHeader(context, ContentType);
await MiddlewareCommon.WriteUtf8Buffer(context.Http, data);
}
