public void Consume(IConsumerByteBuffer buffer)
{
if (_parser == null)
{
_parser = ResponseParser.ParserFor(buffer);
}
else
{
_parser.ParseNext(buffer);
}
buffer.Release();
// don't disperse stowed messages unless a full response has arrived
if (_parser.HasFullResponse())
{
var response = _parser.FullResponse();
if (_testId != EmptyTestId)
{
response.Headers.Add(ResponseHeader.Of(Client.ClientIdCustomHeader, _testId));
}
_completesEventually?.With(response);
_completesEventually = null;
DisperseStowedMessages();
}
if (!_parser.IsMissingContent)
{
_parser = null;
}
}
public void Consume(IConsumerByteBuffer buffer)
{
var bytes = buffer.ToArray();
buffer.Release();
Consume(new ReadOnlySequence <byte>(bytes));
}
public void Consume(IConsumerByteBuffer buffer)
{
var responsePart = buffer.ToArray().BytesToText(0, (int)buffer.Limit());
buffer.Release();
_access.WriteUsing("responses", responsePart);
}
public void Consume(RequestResponseContext context, IConsumerByteBuffer buffer)
{
var bytes = buffer.ToArray();
buffer.Release();
Consume(context, new ReadOnlySequence <byte>(bytes));
}
public StateObject(Socket workSocket, Context context, byte[]?buffer, IConsumerByteBuffer byteBuffer)
{
WorkSocket = workSocket;
Context = context;
Buffer = buffer;
ByteBuffer = byteBuffer;
}
public Context(SocketChannelSelectionProcessorActor parent, Socket clientChannel)
{
_parent = parent;
_clientChannel = clientChannel;
_consumer = parent._provider.RequestChannelConsumer();
_buffer = BasicConsumerByteBuffer.Allocate(++_parent._bufferId, _parent._messageBufferSize);
_id = $"{++_parent._contextId}";
_writables = new Queue <IConsumerByteBuffer>();
}
public Context(SocketChannelSelectionProcessorActor parent, Socket clientChannel)
{
_parent = parent;
_clientChannel = clientChannel;
_consumer = parent._provider.RequestChannelConsumer();
_buffer = parent._requestBufferPool.Acquire();
_id = $"{++_parent._contextId}";
_writables = new Queue <IConsumerByteBuffer>();
}
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 SendTo(IConsumerByteBuffer buffer, Id id)
{
try
{
Open(id);
_provider.ChannelFor(id).Write(buffer.AsStream());
}
finally
{
buffer.Release();
}
}
public void Consume(IConsumerByteBuffer buffer)
{
try
{
if (_state.Parser == null)
{
_state.Parser = ResponseParser.ParserFor(buffer.ToArray());
}
else
{
_state.Parser.ParseNext(buffer.ToArray());
}
while (_state.Parser.HasFullResponse())
{
var response = _state.Parser.FullResponse();
var correlationId = response.Headers.HeaderOf(ResponseHeader.XCorrelationID);
if (correlationId == null)
{
Logger.Warn("Client Consumer: Cannot complete response because no correlation id.");
_state.Configuration.ConsumerOfUnknownResponses.Consume(response);
}
else
{
ICompletesEventually?completes;
if (_completables.TryGetValue(correlationId?.Value !, out completes))
{
if (!_state.Configuration.KeepAlive)
{
_completables.Remove(correlationId?.Value !);
}
}
if (completes == null)
{
_state.Configuration.Stage.World.DefaultLogger.Warn(
$"Client Consumer: Cannot complete response because mismatched correlation id: {correlationId?.Value}");
_state.Configuration.ConsumerOfUnknownResponses.Consume(response);
}
else
{
completes.With(response);
}
}
}
}
finally
{
buffer.Release();
}
}
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;
}
private void WriteWithCachedData(Context context, Socket clientChannel, IConsumerByteBuffer buffer)
{
try
{
var responseBuffer = buffer.ToArray();
var stateObject = new StateObject(clientChannel, context, null, buffer);
// Begin sending the data to the remote device.
clientChannel.BeginSend(responseBuffer, 0, responseBuffer.Length, 0, SendCallback, stateObject);
}
catch (Exception e)
{
Logger.Error($"Failed to write buffer for {_name} with channel {clientChannel.RemoteEndPoint} because: {e.Message}", e);
}
finally
{
buffer.Release();
}
}
internal VirtualStateParser Includes(IConsumerByteBuffer responseContent)
{
_outOfContentTime = 0;
var responseContentText = Converters.BytesToText(responseContent.ToArray());
var utf8ExtraLength = responseContent.Remaining - responseContentText.Length;
if (_contentQueue.Count == 0)
{
_contentExtraLength += (int)utf8ExtraLength;
_responseText = _responseText + responseContentText;
_currentResponseTextLength = _responseText.Length;
}
else
{
_contentQueue.Enqueue(new ContentPacket(responseContentText, (int)utf8ExtraLength));
}
return(this);
}
public void Consume(IConsumerByteBuffer buffer)
{
if (_parser == null)
{
_parser = ResponseParser.ParserFor(buffer.ToArray());
}
else
{
_parser.ParseNext(buffer.ToArray());
}
buffer.Release();
while (_parser.HasFullResponse())
{
var response = _parser.FullResponse();
_progress.ConsumeCalls.WriteUsing("consume", response);
}
}
public void Consume(IConsumerByteBuffer buffer)
{
if (!_actor.IsStopped)
{
Action <IClientConsumer> consumer = actor => actor.Consume(buffer);
if (_mailbox.IsPreallocated)
{
_mailbox.Send(_actor, consumer, null, ConsumeRepresentation3);
}
else
{
_mailbox.Send(new LocalMessage <IClientConsumer>(_actor, consumer, ConsumeRepresentation3));
}
}
else
{
_actor.DeadLetters?.FailedDelivery(new DeadLetter(_actor, ConsumeRepresentation3));
}
}
public void RespondWith(RequestResponseContext context, IConsumerByteBuffer buffer)
{
if (!this.actor.IsStopped)
{
Action <IResponseSenderChannel> consumer = __ => __.RespondWith(context, buffer);
if (this.mailbox.IsPreallocated)
{
this.mailbox.Send(this.actor, consumer, null, RespondWithRepresentation2);
}
else
{
this.mailbox.Send(new LocalMessage <IResponseSenderChannel>(this.actor, consumer,
RespondWithRepresentation2));
}
}
else
{
this.actor.DeadLetters.FailedDelivery(new DeadLetter(this.actor, RespondWithRepresentation2));
}
}
public IConsumerByteBuffer BytesFrom(RawMessage message, IConsumerByteBuffer buffer)
{
message.CopyBytesTo(buffer.Clear().AsStream());
return(buffer.Flip());
}
public void Broadcast(IEnumerable <Node> selectNodes, IConsumerByteBuffer buffer)
{
Broadcast(_provider.ChannelsFor(selectNodes), buffer);
}
public void Broadcast(IConsumerByteBuffer buffer)
{
// currently based on configured nodes,
// but eventually could be live-node based
Broadcast(_provider.AllOtherNodeChannels, buffer);
}
public IConsumerByteBuffer Into(IConsumerByteBuffer consumerByteBuffer) => consumerByteBuffer.Put(Converters.TextToBytes(ToString())).Flip();
public void RespondWith(RequestResponseContext context, IConsumerByteBuffer buffer, bool closeFollowing)
{
((Context)context).QueueWritable(buffer);
((Context)context).RequireExplicitClose(!closeFollowing);
}
private ResponseParser(IConsumerByteBuffer responseContent, bool bodyOnly) =>
private ResponseParser(IConsumerByteBuffer responseContent) =>
public void ParseNext(IConsumerByteBuffer responseContent) => _virtualStateParser.Includes(responseContent).Parse();
public static ResponseParser ParserForBodyOnly(IConsumerByteBuffer requestContent) => new ResponseParser(requestContent, true);
public static ResponseParser ParserFor(IConsumerByteBuffer requestContent) => new ResponseParser(requestContent);
private void Broadcast(IReadOnlyDictionary <Id, IManagedOutboundChannel> channels, IConsumerByteBuffer buffer)
{
try
{
var bufferToWrite = buffer.AsStream();
foreach (var channel in channels.Values)
{
bufferToWrite.Position = 0;
channel.Write(bufferToWrite);
}
}
finally
{
buffer.Release();
}
}
public void Consume(IConsumerByteBuffer buffer)
{
var message = $"{ErrorMessage} Consume()";
Logger.Error(message, new NotSupportedException(message));
}
public void RespondWith(IConsumerByteBuffer buffer) => Sender.RespondWith(this, buffer);
public void RespondWith(RequestResponseContext context, IConsumerByteBuffer buffer) => RespondWith(context, buffer, false);
