public async Task SendAsync()
{
ApplyResponseHeaders(Constants.Status200Ok);
string physicalPath = _fileInfo.PhysicalPath;
var sendFile = _context.Features.Get <IHttpSendFileFeature>();
if (sendFile != null && !string.IsNullOrEmpty(physicalPath))
{
// We don't need to directly cancel this, if the client disconnects it will fail silently.
await sendFile.SendFileAsync(physicalPath, 0, _length, CancellationToken.None);
return;
}
try
{
using (var readStream = _fileInfo.CreateReadStream())
{
// Larger StreamCopyBufferSize is required because in case of FileStream readStream isn't going to be buffering
await StreamCopyOperation.CopyToAsync(readStream, _response.Body, _length, StreamCopyBufferSize, _context.RequestAborted);
}
}
catch (OperationCanceledException ex)
{
_logger.LogWriteCancelled(ex);
// Don't throw this exception, it's most likely caused by the client disconnecting.
// However, if it was cancelled for any other reason we need to prevent empty responses.
_context.Abort();
}
}
internal static async Task WriteFileAsync(HttpContext context, ReadOnlyMemory <byte> buffer, RangeItemHeaderValue?range, long rangeLength)
{
var outputStream = context.Response.Body;
try
{
if (range is null)
{
await outputStream.WriteAsync(buffer, context.RequestAborted);
}
else
{
var from = 0;
var length = 0;
checked
{
// Overflow should throw
from = (int)range.From !.Value;
length = (int)rangeLength;
}
await outputStream.WriteAsync(buffer.Slice(from, length), context.RequestAborted);
}
}
catch (OperationCanceledException)
{
// Don't throw this exception, it's most likely caused by the client disconnecting.
// However, if it was cancelled for any other reason we need to prevent empty responses.
context.Abort();
}
}
public async Task Process(HttpContext context, WebSocket webSocket)
{
this.webSocket = webSocket;
var buffer = new byte[1024 * 4];
WebSocketReceiveResult result;
do
{
result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Text)
{
string content = Encoding.UTF8.GetString(buffer, 0, result.Count);
if (content.Equals("ServerClose"))
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing from Server", CancellationToken.None);
return;
}
else if (content.Equals("ServerAbort"))
{
context.Abort();
}
await HandleKontomatikJson(content);
}
} while (!result.CloseStatus.HasValue);
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}
private static async Task SendFileAsync(this HttpResponse response, FileInfo file)
{
HttpContext context = response.HttpContext;
string physicalPath = file.FullName;
var length = file.Length;
var sendFile = context.Features.Get <IHttpSendFileFeature>();
if (sendFile != null && !string.IsNullOrEmpty(physicalPath))
{
await sendFile.SendFileAsync(physicalPath, 0, length, CancellationToken.None);
return;
}
try
{
using (var readStream = file.OpenRead())
{
await StreamCopyOperation.CopyToAsync(readStream, response.Body, length, 64 * 1024, context.RequestAborted);
}
}
catch (OperationCanceledException)
{
context.Abort();
}
}
// FileResultExecutorBase.WriteFileAsync with custom bufferSize
private async Task WriteFileCoreAsync(HttpContext context, Stream fileStream, RangeItemHeaderValue range, long rangeLength)
{
var outputStream = context.Response.Body;
await using (fileStream)
{
try
{
if (range == null)
{
await StreamCopyOperation.CopyToAsync(fileStream, outputStream, count : null, bufferSize : _bufferSize, cancel : context.RequestAborted);
}
else
{
fileStream.Seek(range.From.Value, SeekOrigin.Begin);
await StreamCopyOperation.CopyToAsync(fileStream, outputStream, rangeLength, _bufferSize, context.RequestAborted);
}
}
catch (OperationCanceledException)
{
// Don't throw this exception, it's most likely caused by the client disconnecting.
// However, if it was cancelled for any other reason we need to prevent empty responses.
context.Abort();
}
}
}
public async Task Invoke(HttpContext context)
{
Request request = Repository.AddRequest(context.Request);
Task.Delay(Configuration.CostKeepingTime * 60 * 100).ContinueWith((t) => Repository.RemoveRequest(request));
ClientIp clientIp = request.ClientIp;
if (clientIp.IsWhiteListed)
{
await _next.Invoke(context);
}
else
{
if (clientIp.IsBlackListed || clientIp.CurrentRequestCosts > Configuration.BlockingLimitPerIp)
{
_logger.LogError(0, $"Request blocked from: {clientIp.Ip}");
request.IsBlocked = true;
request.Costs = Configuration.BlockingLimitPerIp;
context.Abort();
return;
}
Task requestTask = _next.Invoke(context);
request.Costs = CalculateStaticCosts(request);
await requestTask;
CalculateDynamicRequestCosts(context, request);
foreach (ICostMultiplier multiplier in Configuration.CostMultipliers)
{
request.Costs = request.Costs * (int)multiplier.Calculate(request);
}
//Task.Run(() => CheckBlocking(request));
_logger.LogInformation(0,
$"Request from: {clientIp.Ip}, Costs: {request.Costs}, Costs for IP: {clientIp.CurrentRequestCosts}, Duration: {DateTime.Now.Subtract(request.Time).Milliseconds} ms");
}
}
private async Task Echo(HttpContext context, WebSocket webSocket, ILogger logger)
{
var buffer = new byte[1024 * 4];
var result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
while (!result.CloseStatus.HasValue)
{
string content = "<<binary>>";
if (result.MessageType == WebSocketMessageType.Text)
{
content = Encoding.UTF8.GetString(buffer, 0, result.Count);
if (content.Equals("ServerClose"))
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing from Server", CancellationToken.None);
logger.LogDebug($"Sent Frame Close: {WebSocketCloseStatus.NormalClosure} Closing from Server");
return;
}
else if (content.Equals("ServerAbort"))
{
context.Abort();
}
}
await webSocket.SendAsync(new ArraySegment <byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None);
logger.LogDebug($"Sent Frame {result.MessageType}: Len={result.Count}, Fin={result.EndOfMessage}: {content}");
result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
}
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}
public async Task InvokeAsync(HttpContext context, RequestDelegate next)
{
try
{
if (await _fileServer.TryServeFile(context, CancellationToken.None))
{
return;
}
}
catch (OperationCanceledException)
{
if (context.Response.HasStarted)
{
context.Abort();
}
else
{
context.Response.StatusCode = StatusCodes.Status408RequestTimeout;
}
return;
}
await next.Invoke(context);
}
private async Task SendAsync(HttpContext context, StaticFileInfo fileInfo)
{
SetCompressionMode(context);
context.Response.StatusCode = 200;
context.Response.ContentLength = fileInfo.File.Length;
context.Response.ContentType = fileInfo.ContentType;
ResponseHeaders headers = context.Response.GetTypedHeaders();
headers.LastModified = fileInfo.File.LastModified;
headers.ETag = fileInfo.EntityTagHeader;
headers.Headers[HeaderNames.AcceptRanges] = "bytes";
try
{
await context.Response.SendFileAsync(
fileInfo.File,
0,
fileInfo.File.Length,
context.RequestAborted);
}
catch (OperationCanceledException)
{
context.Abort();
}
}
private async Task WriteFileAsync(HttpContext context, FileAuthorizeResult result, FileInfo fileInfo)
{
var response = context.Response;
var sendFile = response.HttpContext.Features.Get <IHttpSendFileFeature>();
if (sendFile != null)
{
await sendFile.SendFileAsync(fileInfo.FullName, 0L, null, default(CancellationToken));
return;
}
using (var fileStream = new FileStream(
fileInfo.FullName,
FileMode.Open,
FileAccess.Read,
FileShare.ReadWrite,
BufferSize,
FileOptions.Asynchronous | FileOptions.SequentialScan))
{
try
{
await StreamCopyOperation.CopyToAsync(fileStream, context.Response.Body, count : null, bufferSize : BufferSize, cancel : context.RequestAborted);
}
catch (OperationCanceledException)
{
// Don't throw this exception, it's most likely caused by the client disconnecting.
// However, if it was cancelled for any other reason we need to prevent empty responses.
context.Abort();
}
}
}
public async Task PostExport()
{
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
var operationId = GetLongQueryString("operationId", false) ?? Database.Operations.GetNextOperationId();
var startDocumentEtag = GetLongQueryString("startEtag", false) ?? 0;
var stream = TryGetRequestFromStream("DownloadOptions") ?? RequestBodyStream();
DatabaseSmugglerOptionsServerSide options;
using (context.GetManagedBuffer(out var buffer))
{
var firstRead = await stream.ReadAsync(buffer.Buffer.Array, buffer.Buffer.Offset, buffer.Buffer.Count);
buffer.Used = 0;
buffer.Valid = firstRead;
if (firstRead != 0)
{
var blittableJson = await context.ParseToMemoryAsync(stream, "DownloadOptions", BlittableJsonDocumentBuilder.UsageMode.None, buffer);
options = JsonDeserializationServer.DatabaseSmugglerOptions(blittableJson);
}
else
{
// no content, we'll use defaults
options = new DatabaseSmugglerOptionsServerSide();
}
}
ApplyBackwardCompatibility(options);
var token = CreateOperationToken();
var fileName = options.FileName;
if (string.IsNullOrEmpty(fileName))
{
fileName = $"Dump of {context.DocumentDatabase.Name} {SystemTime.UtcNow.ToString("yyyy-MM-dd HH-mm", CultureInfo.InvariantCulture)}";
}
var contentDisposition = "attachment; filename=" + Uri.EscapeDataString(fileName) + ".ravendbdump";
HttpContext.Response.Headers["Content-Disposition"] = contentDisposition;
try
{
await Database.Operations.AddOperation(
Database,
"Export database: " + Database.Name,
Operations.OperationType.DatabaseExport,
onProgress => Task.Run(() => ExportDatabaseInternal(options, startDocumentEtag, onProgress, context, token), token.Token), operationId, token : token);
}
catch (Exception)
{
HttpContext.Abort();
}
}
}
public void WhenConnectionIsClosedByClient_ConnectionClosedEventShouldBeRaised()
{
using var eventMonitor = _sut.Monitor();
_context.Abort();
eventMonitor.Should().Raise(nameof(_sut.ConnectionClosed))
.WithSender(_sut);
}
Task closeConnection(HttpContext httpContext)
{
return(Task.Run(() =>
{
Task.Delay(1000).Wait();
httpContext.Abort();
}));
}
private void DeadlineExceeded(object state)
{
DeadlineExceeded(_logger, (TimeSpan)state);
StatusCore = new Status(StatusCode.DeadlineExceeded, "Deadline Exceeded");
// TODO(JamesNK): I believe this sends a RST_STREAM with INTERNAL_ERROR. Grpc.Core sends NO_ERROR
HttpContext.Abort();
}
private async Task ProcessWebSocketMessages(HttpContext context, WebSocket webSocket, IRepository repository, ILogger logger)
{
var buffer = new byte[1024 * 4];
int bytesToSend;
var result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
bytesToSend = result.Count;
LogFrame(logger, result, buffer);
while (!result.CloseStatus.HasValue)
{
// If the client send "ServerClose", then they want a server-originated close to occur
string content = "<<binary>>";
if (result.MessageType == WebSocketMessageType.Text)
{
content = Encoding.UTF8.GetString(buffer, 0, result.Count);
// repository.Add(new RepositoryItem { Created = DateTime.Now, Message = content });
if (content.Equals("ServerClose"))
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing from Server", CancellationToken.None);
logger.LogDebug($"Sent Frame Close: {WebSocketCloseStatus.NormalClosure} Closing from Server");
return;
}
else if (content.Equals("ServerAbort"))
{
context.Abort();
}
else if (content.Equals("Feed"))
{
StringBuilder sb = new StringBuilder();
foreach (var item in repository.GetAll())
{
sb.Append(item.Message);
}
byte[] bytes = Encoding.UTF8.GetBytes(sb.ToString());
bytes.CopyTo(buffer, 0);
bytesToSend = bytes.Length;
}
}
await webSocket.SendAsync(new ArraySegment <byte>(buffer, 0, bytesToSend), result.MessageType, result.EndOfMessage, CancellationToken.None);
logger.LogDebug($"Sent Frame {result.MessageType}: Len={result.Count}, Fin={result.EndOfMessage}: {content}");
result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
bytesToSend = result.Count;
LogFrame(logger, result, buffer);
}
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}
public static Task RejectAsync([NotNull] this HttpContext context)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
context.Response.SetStatusCode(HttpStatusCode.ServiceUnavailable);
context.Abort();
return(Task.CompletedTask);
}
static async Task CentaurusWebSocketHandler(HttpContext context, Func <Task> next)
{
if (Global.AppState == null || ValidApplicationStates.Contains(Global.AppState.State))
{
using (var webSocket = await context.WebSockets.AcceptWebSocketAsync())
await ConnectionManager.OnNewConnection(webSocket, context.Connection.RemoteIpAddress.ToString());
}
else
{
context.Abort();
}
}
public async Task Invoke(HttpContext context)
{
if (enableAuthCheck &&
protectedControllers.Any(c => context.Request.Path.Value.ToLower().Contains(c)) &&
(!context.Request.Headers.Any(h => h.Key == "PraxisAuthKey" && h.Value == ServerAuthKey) && !context.Request.Query.Any(q => q.Key == "PraxisAuthKey" && q.Value == ServerAuthKey)))
{
context.Abort();
return;
}
await this._next.Invoke(context).ConfigureAwait(false);
}
public async Task Invoke(HttpContext context)
{
bool isAlllowed = whitelistedIps.Any(_ip => _ip.SequenceEqual(context.Connection.RemoteIpAddress.GetAddressBytes()));
if (isAlllowed)
{
await nextRequest.Invoke(context);
}
else
{
context.Abort();
}
}
private async Task Echo(HttpContext context, IWebSocketConnection webSocket, ILogger logger)
{
var lastFrameOpcode = WebSocketOpcode.Continuation;
var closeResult = await webSocket.ExecuteAsync(frame =>
{
if (frame.Opcode == WebSocketOpcode.Ping || frame.Opcode == WebSocketOpcode.Pong)
{
// Already handled
return(Task.CompletedTask);
}
LogFrame(logger, lastFrameOpcode, ref frame);
// If the client send "ServerClose", then they want a server-originated close to occur
string content = "<<binary>>";
if (frame.Opcode == WebSocketOpcode.Text)
{
// Slooooow
content = Encoding.UTF8.GetString(frame.Payload.ToArray());
if (content.Equals("ServerClose"))
{
logger.LogDebug($"Sending Frame Close: {WebSocketCloseStatus.NormalClosure} Closing from Server");
return(webSocket.CloseAsync(new WebSocketCloseResult(WebSocketCloseStatus.NormalClosure, "Closing from Server")));
}
else if (content.Equals("ServerAbort"))
{
context.Abort();
}
}
if (frame.Opcode != WebSocketOpcode.Continuation)
{
lastFrameOpcode = frame.Opcode;
}
logger.LogDebug($"Sending {frame.Opcode}: Len={frame.Payload.Length}, Fin={frame.EndOfMessage}: {content}");
return(webSocket.SendAsync(frame));
});
if (webSocket.State == WebSocketConnectionState.CloseReceived)
{
// Close the connection from our end
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure);
logger.LogDebug("Socket closed");
}
else if (webSocket.State != WebSocketConnectionState.Closed)
{
logger.LogError("WebSocket closed but not closed?");
}
}
static async Task CentaurusWebSocketHandler(HttpContext context, Func <Task> next)
{
var centaurusContext = context.RequestServices.GetService <AlphaContext>();
if (centaurusContext.AppState == null || ValidApplicationStates.Contains(centaurusContext.AppState.State))
{
using (var webSocket = await context.WebSockets.AcceptWebSocketAsync())
await centaurusContext.ConnectionManager.OnNewConnection(webSocket, context.Connection.RemoteIpAddress.ToString());
}
else
{
context.Abort();
}
}
public async Task PostExport()
{
DocumentsOperationContext context;
using (ContextPool.AllocateOperationContext(out context))
using (context.OpenReadTransaction())
{
var operationId = GetIntValueQueryString("operationId", required: false);
var stream = TryGetRequestFormStream("DownloadOptions") ?? RequestBodyStream();
var blittableJson = await context.ReadForMemoryAsync(stream, "DownloadOptions");
var options = JsonDeserializationServer.DatabaseSmugglerOptions(blittableJson);
var exporter = new SmugglerExporter(Database, options);
var token = CreateOperationToken();
var fileName = exporter.Options.FileName;
if (string.IsNullOrEmpty(fileName))
{
fileName = $"Dump of {context.DocumentDatabase.Name} {SystemTime.UtcNow.ToString("yyyy-MM-dd HH-mm", CultureInfo.InvariantCulture)}";
}
var contentDisposition = "attachment; filename=" + Uri.EscapeDataString(fileName) + ".ravendbdump";
HttpContext.Response.Headers["Content-Disposition"] = contentDisposition;
if (operationId.HasValue)
{
try
{
await
Database.Operations.AddOperation("Export database: " + Database.Name,
DatabaseOperations.PendingOperationType.DatabaseExport,
onProgress =>
Task.Run(() => ExportDatabaseInternal(context, exporter, onProgress, token),
token.Token), operationId.Value, token);
}
catch (Exception)
{
HttpContext.Abort();
}
}
else
{
ExportDatabaseInternal(context, exporter, null, token);
}
}
}
public async Task Invoke(HttpContext httpContext)
{
string accessToken = httpContext.Request.Headers["Authorization"];
var client = _httpClientFactory.CreateClient("laravel");
client.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", accessToken);
var res = await client.GetAsync("api/user");
if (!res.IsSuccessStatusCode)
{
httpContext.Abort();
}
var user = (await res.Content.ReadAsAsync <User>());
if (user == null)
{
httpContext.Abort();
}
Console.WriteLine(httpContext.User.ToString());
await _next(httpContext);
}
private static void ResetOrAbort(HttpContext context, bool isCancelled)
{
var resetFeature = context.Features.Get <IHttpResetFeature>();
if (resetFeature != null)
{
// https://tools.ietf.org/html/rfc7540#section-7
const int Cancelled = 2;
const int InternalError = 8;
resetFeature.Reset(isCancelled ? Cancelled : InternalError);
return;
}
context.Abort();
}
public async Task InvokeAsync(HttpContext context)
{
Console.WriteLine("\n ----- Antes ----- \n");
bool abort = context.Request.Path.Equals("/abort");
if (abort)
{
context.Abort();
}
await this._next(context);
Console.WriteLine("\n ----- Depois ----- \n");
}
public async Task InvokeAsync(HttpContext context, UserManager <ApplicationUser> userManager)
{
var user = await userManager.GetUserAsync(context.User);
if (user is not null &&
(user.IsAdmin != context.User.IsInRole("GroupAdmin") ||
user.GroupId.ToString() != context.User.Claims.Single(c => c.Type == "household").Value))
{
await context.Response.WriteAsJsonAsync(new ForbidResult());
context.Abort();
return;
}
await _next(context);
}
public async Task InvokeAsync(HttpContext context)
{
if (IsDisabled(context))
{
await next(context);
return;
}
var info = FlowingContext.Globals.Get <IRequestInfo>();
var properties = BuildThrottlingProperties(context, info);
using (var result = await provider.ThrottleAsync(properties, info?.RemainingTimeout))
{
if (context.RequestAborted.IsCancellationRequested)
{
LogConnectionAlreadyAborted(context, info);
return;
}
if (result.Status == ThrottlingStatus.Passed)
{
if (result.WaitTime >= LongThrottlingWaitTime)
{
LogWaitTime(context, info, result);
}
await next(context);
return;
}
LogFailure(context, info, result);
if (ShouldAbortConnection(context, result))
{
LogAbortingConnection();
context.Abort();
}
else
{
context.Response.StatusCode = options.RejectionResponseCode;
context.Response.Headers.ContentLength = 0L;
}
}
}
public static async Task StreamAsync(this IEventStreamer eventStreamer, String topic, HttpContext httpContext)
{
var buffer = new ArraySegment <Byte>(new Byte[4096]);
var webSocket = await httpContext.WebSockets.AcceptWebSocketAsync();
await eventStreamer.StreamAsync(topic, httpContext.RequestAborted, async message =>
{
await webSocket.SendTextAsync(message);
var receiveResult = await webSocket.ReceiveAsync(buffer, httpContext.RequestAborted);
if (receiveResult.CloseStatus.HasValue)
{
httpContext.Abort();
}
});
}
private async Task ServeResponse()
{
var fileInfo = _fileProvider.GetFileInfo(_selectedVariant !.FileName);
if (fileInfo == null)
{
// TODO is "Not Found" really the right logic here?
// We are not finding a file that should be there on the server, and the fact that it isn't
// is more indicative of a misconfiguration or inconsistent server deployment.
await RespondNotFound();
return;
}
_response.StatusCode = StatusCodes.Status200OK;
SetFileHeaders();
// do not actually send an entity in response to a HEAD request
if (IsHead)
{
return;
}
if (fileInfo.PhysicalPath != null)
{
var sendFile = _context.Features.Get <IHttpResponseBodyFeature>();
if (sendFile != null)
{
await sendFile.SendFileAsync(fileInfo.PhysicalPath, 0, _selectedVariant.Size);
return;
}
}
try
{
await using (var readStream = fileInfo.CreateReadStream())
{
await readStream.CopyToAsync(_response.Body, 16384, _context.RequestAborted);
}
}
catch (OperationCanceledException)
{
_context.Abort();
}
}
private async Task SendMessagesAsync(HttpContext context, WebSocket webSocket, ILogger logger)
{
var buffer = new byte[4096];
WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
while (!result.CloseStatus.HasValue)
{
if (result.MessageType == WebSocketMessageType.Text)
{
string content = Encoding.UTF8.GetString(buffer, 0, result.Count);
if (content.StartsWith("REQUESTMESSAGES:"))
{
string message = content.Substring("REQUESTMESSAGES:".Length);
for (int i = 0; i < 10; i++)
{
string messageToSend = $"{message} - {i}";
if (i == 9)
{
messageToSend += ";EOS"; // send end of sequence to not let the client wait for another message
}
byte[] sendBuffer = Encoding.UTF8.GetBytes(messageToSend);
await webSocket.SendAsync(new ArraySegment <byte>(sendBuffer), WebSocketMessageType.Text, endOfMessage : true, CancellationToken.None);
logger.LogDebug("sent message {0}", messageToSend);
await Task.Delay(1000);
}
}
if (content.Equals("SERVERCLOSE"))
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Bye for now", CancellationToken.None);
logger.LogDebug("client sent close request, socket closing");
return;
}
else if (content.Equals("SERVERABORT"))
{
context.Abort();
}
}
result = await webSocket.ReceiveAsync(buffer, CancellationToken.None);
}
}