public static void LogResponse(RequestResponseContext filterContext)
{
using (DatabaseContext context = new DatabaseContext())
{
sqlDatabase.ExecuteNonQuery(Procedure.spLog_Update_Response, filterContext.ControllerAction.Id, filterContext.JsonResponse);
}
}
public void Consume(RequestResponseContext context, IConsumerByteBuffer buffer)
{
var bytes = buffer.ToArray();
buffer.Release();
Consume(context, new ReadOnlySequence <byte>(bytes));
}
internal ResponseCompletes(ServerActor serverActor, Request request, RequestResponseContext requestResponseContext, Header?correlationId) : base(serverActor.Stage.Scheduler)
{
_serverActor = serverActor;
_request = request;
_requestResponseContext = requestResponseContext;
_correlationId = correlationId;
}
public void Consume(RequestResponseContext requestResponseContext, IConsumerByteBuffer buffer)
{
try
{
RequestParser parser;
var wasIncompleteContent = false;
if (!requestResponseContext.HasConsumerData)
{
parser = RequestParser.ParserFor(buffer);
requestResponseContext.ConsumerData(parser);
}
else
{
parser = requestResponseContext.ConsumerData <RequestParser>();
wasIncompleteContent = parser.IsMissingContent;
parser.ParseNext(buffer);
}
Context?context = null;
while (parser.HasFullRequest())
{
var unfilteredRequest = parser.FullRequest();
unfilteredRequest = EnrichRequest(requestResponseContext, unfilteredRequest);
DetermineKeepAlive(requestResponseContext, unfilteredRequest);
var request = _serverActor._filters.Process(unfilteredRequest);
var completes = new ResponseCompletes(_serverActor, requestResponseContext, request.Headers.HeaderOf(RequestHeader.XCorrelationID));
context = new Context(requestResponseContext, request, _serverActor._world.CompletesFor(completes));
_dispatcher.DispatchFor(context);
if (wasIncompleteContent)
{
_serverActor._requestsMissingContent.Remove(requestResponseContext.Id);
}
}
if (parser.IsMissingContent && !_serverActor._requestsMissingContent.ContainsKey(requestResponseContext.Id))
{
if (context == null)
{
var completes = new ResponseCompletes(_serverActor, requestResponseContext);
context = new Context(_serverActor._world.CompletesFor(completes));
}
_serverActor._requestsMissingContent.Add(requestResponseContext.Id, new RequestResponseHttpContext(requestResponseContext, context));
}
}
catch (Exception e)
{
_serverActor.Logger.Error("Request parsing failed.", e);
new ResponseCompletes(_serverActor, requestResponseContext, null).With(Response.Of(ResponseStatus.BadRequest, e.Message));
}
finally
{
buffer.Release();
}
}
public void CloseWith(RequestResponseContext requestResponseContext, object?data)
{
if (data != null)
{
var request = _serverActor._filters.Process((Request)data);
var completes = new ResponseCompletes(_serverActor, requestResponseContext, request.Headers.HeaderOf(RequestHeader.XCorrelationID));
var context = new Context(requestResponseContext, request, _serverActor._world.CompletesFor(completes));
_dispatcher.DispatchFor(context);
}
}
public void RespondWith(RequestResponseContext context, object response, bool closeFollowing)
{
var textResponse = response.ToString();
if (!string.IsNullOrEmpty(textResponse))
{
var buffer =
new BasicConsumerByteBuffer(0, textResponse.Length + 1024)
.Put(Converters.TextToBytes(textResponse)).Flip();
RespondWith(context, buffer, closeFollowing);
}
}
public void RespondWith(RequestResponseContext context, IConsumerByteBuffer buffer)
{
var parser = _receivedStatus ?
ResponseParser.ParserForBodyOnly(buffer.ToArray()) :
ResponseParser.ParserFor(buffer.ToArray());
if (!_receivedStatus)
{
Response.Set(parser.FullResponse());
}
else
{
_respondWithSafely.WriteUsing("events", parser.FullResponse());
}
_receivedStatus = true;
}
public void Abandon(RequestResponseContext context)
{
if (!_actor.IsStopped)
{
Action <IResponseSenderChannel> cons8585439 = __ => __.Abandon(context);
if (_mailbox.IsPreallocated)
{
_mailbox.Send(_actor, cons8585439, null, AbandonRepresentation1);
}
else
{
_mailbox.Send(
new LocalMessage <IResponseSenderChannel>(_actor, cons8585439,
AbandonRepresentation1));
}
}
else
{
_actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, AbandonRepresentation1));
}
}
private Request EnrichRequest(RequestResponseContext requestResponseContext, Request request)
{
try
{
var remoteAddress = requestResponseContext.RemoteAddress();
if (!string.IsNullOrEmpty(remoteAddress))
{
request.Headers.Add(RequestHeader.Of(RequestHeader.XForwardedFor, remoteAddress !));
}
else
{
_serverActor.Logger.Error("Unable to enrich request headers");
}
}
catch (Exception exception)
{
_serverActor.Logger.Error("Unable to enrich request headers", exception);
}
return(request);
}
public void Consume <T>(RequestResponseContext <T> context, ReadOnlySequence <byte> buffer)
{
var requestPart = buffer.ToArray().BytesToText(0, (int)buffer.Length);
_requestBuilder.Append(_remaining).Append(requestPart);
_remaining = string.Empty;
if (_requestBuilder.Length >= CurrentExpectedRequestLength)
{
// assume currentExpectedRequestLength is length of all
// requests when multiple are received at one time
var combinedRequests = _requestBuilder.ToString();
var combinedLength = combinedRequests.Length;
_requestBuilder.Clear(); // reuse
var startIndex = 0;
var currentIndex = 0;
var last = false;
while (!last)
{
if (startIndex > combinedRequests.Length)
{
_remaining = combinedRequests.Substring(currentIndex);
return;
}
var request = combinedRequests.Substring(startIndex, CurrentExpectedRequestLength);
currentIndex += CurrentExpectedRequestLength;
startIndex = startIndex + CurrentExpectedRequestLength;
Requests.Add(request);
var responseBuffer = new BasicConsumerByteBuffer(1, CurrentExpectedRequestLength);
context.RespondWith(responseBuffer.Clear().Put(Converters.TextToBytes(request)).Flip()); // echo back
last = currentIndex == combinedLength;
UntilConsume.WriteUsing("serverConsume", 1);
}
}
}
public void RespondWith(RequestResponseContext context,
Message.IConsumerByteBuffer buffer, bool closeFollowing)
{
if (!_actor.IsStopped)
{
Action <IResponseSenderChannel> cons829071244 = __ =>
__.RespondWith(context, buffer, closeFollowing);
if (_mailbox.IsPreallocated)
{
_mailbox.Send(_actor, cons829071244, null, RespondWithRepresentation3);
}
else
{
_mailbox.Send(new LocalMessage <IResponseSenderChannel>(_actor,
cons829071244, RespondWithRepresentation3));
}
}
else
{
_actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, RespondWithRepresentation3));
}
}
public void RespondWith(RequestResponseContext context, object response,
bool closeFollowing)
{
if (!_actor.IsStopped)
{
Action <IResponseSenderChannel> cons1528567494 = __ =>
__.RespondWith(context, response, closeFollowing);
if (_mailbox.IsPreallocated)
{
_mailbox.Send(_actor, cons1528567494, null, RespondWithRepresentation4);
}
else
{
_mailbox.Send(new LocalMessage <IResponseSenderChannel>(_actor,
cons1528567494, RespondWithRepresentation4));
}
}
else
{
_actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, RespondWithRepresentation4));
}
}
public void RespondWith(RequestResponseContext context, object response, bool closeFollowing)
{
var textResponse = response.ToString();
var buffer =
new BasicConsumerByteBuffer(0, textResponse !.Length + 1024)
.Put(Converters.TextToBytes(textResponse)).Flip();
var parser = _receivedStatus ?
ResponseParser.ParserForBodyOnly(buffer) :
ResponseParser.ParserFor(buffer);
if (!_receivedStatus)
{
Response.Set(parser.FullResponse());
}
else
{
_respondWithSafely.WriteUsing("events", parser.FullResponse());
}
_receivedStatus = true;
}
public void Abandon(RequestResponseContext context) => ((Context)context).Close();
public SseClient(RequestResponseContext <object> context)
{
_context = context;
_builder = new StringBuilder();
_maxMessageSize = Configuration.Instance.Sizing.MaxMessageSize;
}
public void LogResponse(RequestResponseContext filterContext)
{
RequestResponseDbAccess.LogResponse(filterContext);
}
private bool DetermineKeepAlive(RequestResponseContext requestResponseContext, Request unfilteredRequest)
{
var keepAlive = unfilteredRequest.HeaderValueOr(RequestHeader.Connection, Header.ValueKeepAlive).Equals(Header.ValueKeepAlive);
return(keepAlive);
}
public Logger()
{
FilterContext = new RequestResponseContext();
FilterContext.ControllerAction = new ControllerAction();
}
public void CloseWith <T>(RequestResponseContext <T> requestResponseContext, object data) => UntilClosed.WriteUsing("closed", 1);
public void RespondWith(RequestResponseContext context, IConsumerByteBuffer buffer) => RespondWith(context, buffer, false);
public void RespondWith(RequestResponseContext context, IConsumerByteBuffer buffer, bool closeFollowing)
{
((Context)context).QueueWritable(buffer);
((Context)context).RequireExplicitClose(!closeFollowing);
}
public EmployeeService(RequestResponseContext context)
{
_context = context;
}
public void CloseWith(RequestResponseContext requestResponseContext, object data)
{
}
internal ResponseCompletes(ServerActor serverActor, RequestResponseContext requestResponseContext) : this(serverActor, requestResponseContext, null)
{
}
public void Abandon(RequestResponseContext context)
{
var count = AbandonCount.IncrementAndGet();
_abandonSafely.WriteUsing("count", count);
}
public RequestResponseService(RequestResponseContext context)
{
_context = context;
}
public Context(RequestResponseContext <object> requestResponseContext, Request request, ICompletesEventually completes)
{
ClientContext = requestResponseContext;
Request = request;
_completes = completes;
}
public RequestResponseHttpContext(RequestResponseContext requestResponseContext, Context httpContext)
{
RequestResponseContext = requestResponseContext;
HttpContext = httpContext;
}
