private void ConsumeMessages(IResponsePipeline pipeline, int messages)
{
var leftMessages = messages;
while (_bufferStream.Length > _bufferStream.Position && leftMessages > 0)
{
ProcessMessage(pipeline);
leftMessages -= 1;
}
// Check whether we have incomplete message in the buffers
if (_bufferStream.Length == _bufferStream.Position)
{
_bufferStream.SetLength(0);
if (_bufferStream.Capacity > _maxBufferSize)
{
_logger?.Info(
$@"Shrinking read buffers to the default read buffer size {
_defaultBufferSize
} since its size reached {
_bufferStream.Capacity
} which is larger than the maximum read buffer size {
_maxBufferSize
}. This has already occurred {_shrinkCounter} times for this connection.");
_shrinkCounter += 1;
_bufferStream.Capacity = _defaultBufferSize;
}
}
}
public async Task ReceiveOneAsync(IResponsePipeline responsePipeline)
{
try
{
await Reader.ReadAsync(responsePipeline).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger?.Error(ex, $"Unable to read message from server {_uri}, connection will be terminated.");
await StopAsync().ConfigureAwait(false);
throw;
}
// We force ProtocolException's to be thrown here to shortcut the communication with the server
try
{
responsePipeline.AssertNoProtocolViolation();
}
catch (ProtocolException exc)
{
_logger?.Warn(exc, "A bolt protocol error has occurred with server {0}, connection will be terminated.",
_uri.ToString());
await StopAsync().ConfigureAwait(false);
throw;
}
}
internal static SocketConnection NewSocketConnection(ISocketClient socketClient = null,
IResponsePipeline pipeline = null, IServerInfo server = null, ILogger logger = null)
{
socketClient = socketClient ?? SocketClient;
server = server ?? Server;
return(new SocketConnection(socketClient, AuthToken, UserAgent, logger ?? Logger, server, pipeline));
}
public async Task ReceiveAsync(IResponsePipeline responsePipeline)
{
while (!responsePipeline.HasNoPendingMessages)
{
await ReceiveOneAsync(responsePipeline).ConfigureAwait(false);
}
}
public ExecutionService(IRouteRepository routeRepository, IRequestRepository requestRepository, ITopicFactory topicFactory, IResponsePipeline responsePipeline, ITraceContext traceContext)
{
_routeRepository = routeRepository;
_requestRepository = requestRepository;
_topicFactory = topicFactory;
_responsePipeline = responsePipeline;
_traceContext = traceContext;
}
private void ProcessMessage(IResponsePipeline pipeline)
{
var message = _packStreamReader.Read();
if (message is IResponseMessage response)
{
response.Dispatch(pipeline);
}
else
{
throw new ProtocolException($"Unknown response message type {message.GetType().FullName}");
}
}
public SocketConnection(Uri uri, ConnectionSettings connectionSettings, BufferSettings bufferSettings, ILogger logger = null)
{
_idPrefix = $"conn-{uri.Host}:{uri.Port}-";
_id = $"{_idPrefix}{UniqueIdGenerator.GetId()}";
_logger = new PrefixLogger(logger, FormatPrefix(_id));
_client = new SocketClient(uri, connectionSettings.SocketSettings, bufferSettings, _logger);
_authToken = connectionSettings.AuthToken;
_userAgent = connectionSettings.UserAgent;
Server = new ServerInfo(uri);
_responsePipeline = new ResponsePipeline(_logger);
}
// for test only
internal SocketConnection(ISocketClient socketClient, IAuthToken authToken,
string userAgent, ILogger logger, IServerInfo server,
IResponsePipeline responsePipeline = null)
{
Throw.ArgumentNullException.IfNull(socketClient, nameof(socketClient));
Throw.ArgumentNullException.IfNull(authToken, nameof(authToken));
Throw.ArgumentNullException.IfNull(userAgent, nameof(userAgent));
Throw.ArgumentNullException.IfNull(server, nameof(server));
_client = socketClient;
_authToken = authToken;
_userAgent = userAgent;
Server = server;
_id = $"{_idPrefix}{UniqueIdGenerator.GetId()}";
_logger = new PrefixLogger(logger, FormatPrefix(_id));
_responsePipeline = responsePipeline ?? new ResponsePipeline(logger);
}
public void Dispatch(IResponsePipeline pipeline)
{
pipeline.OnSuccess(Meta);
}
public async Task ReadAsync(IResponsePipeline pipeline)
{
var messageCount = await _chunkReader.ReadNextMessagesAsync(_bufferStream).ConfigureAwait(false);
ConsumeMessages(pipeline, messageCount);
}
public void Dispatch(IResponsePipeline pipeline)
{
pipeline.OnFailure(Code, Message);
}
public void Dispatch(IResponsePipeline pipeline)
{
pipeline.OnIgnored();
}
public void Dispatch(IResponsePipeline pipeline)
{
pipeline.OnRecord(Fields);
}
