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); }