private void Receive(IMessageResponseHandler responseHandler) { while (!responseHandler.QueueIsEmpty()) { try { _reader.Read(responseHandler); } catch (Exception ex) { _config.Logger.Error("Unable to unpack message from server, connection has been terminated.", ex); Task.Run(() => Stop()).Wait(); throw; } if (responseHandler.HasError) { if (responseHandler.Error.Code.ToLowerInvariant().Contains("clienterror.request")) { Task.Run(() => Stop()).Wait(); throw responseHandler.Error; } } } //Read 1 message //Send to handler, //While messages read < messages handled keep doing above. }
private void ProcessMessage(IMessageResponseHandler responseHandler) { var message = _packStreamReader.Read(); if (message is RecordMessage record) { record.Dispatch(responseHandler); } else if (message is SuccessMessage success) { success.Dispatch(responseHandler); } else if (message is FailureMessage failure) { failure.Dispatch(responseHandler); } else if (message is IgnoredMessage ignored) { ignored.Dispatch(responseHandler); } else { throw new ProtocolException("Unknown response message type: " + message.GetType().FullName); } }
public void Receive(IMessageResponseHandler responseHandler) { while (responseHandler.UnhandledMessageSize > 0) { ReceiveOne(responseHandler); } }
public async Task ReceiveAsync(IMessageResponseHandler responseHandler) { while (responseHandler.UnhandledMessageSize > 0) { await ReceiveOneAsync(responseHandler).ConfigureAwait(false); } }
private void ConsumeMessages(IMessageResponseHandler responseHandler, int messages) { var leftMessages = messages; while (_bufferStream.Length > _bufferStream.Position && leftMessages > 0) { ProcessMessage(responseHandler); 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 void Read(IMessageResponseHandler responseHandler) { _unpacker.UnpackStructHeader(); var type = _unpacker.UnpackStructSignature(); switch (type) { case MSG_RECORD: UnpackRecordMessage(responseHandler); break; case MSG_SUCCESS: UnpackSuccessMessage(responseHandler); break; case MSG_FAILURE: UnpackFailureMessage(responseHandler); break; case MSG_IGNORED: UnpackIgnoredMessage(responseHandler); break; default: throw new IOException("Unknown requestMessage type: " + type); } UnPackMessageTail(); }
// for testing only internal SocketConnection(ISocketClient socketClient, IAuthToken authToken, ILogger logger, IMessageResponseHandler messageResponseHandler = null) { Throw.ArgumentNullException.IfNull(socketClient, nameof(socketClient)); _responseHandler = messageResponseHandler ?? new MessageResponseHandler(logger); _client = socketClient; _authToken = authToken; }
private void UnpackFailureMessage(IMessageResponseHandler responseHandler) { var values = UnpackMap(); var code = values["code"]?.ToString(); var message = values["message"]?.ToString(); responseHandler.HandleFailureMessage(code, message); }
public Task ReadAsync(IMessageResponseHandler responseHandler) { return (_chunkReader.ReadNextMessagesAsync(_bufferStream) .ContinueWith(t => { ConsumeMessages(responseHandler, t.Result); }, TaskContinuationOptions.ExecuteSynchronously)); }
private void UnpackRecordMessage(IMessageResponseHandler responseHandler) { var fieldCount = (int)_unpacker.UnpackListHeader(); var fields = new object[fieldCount]; for (var i = 0; i < fieldCount; i++) { fields[i] = UnpackValue(); } responseHandler.HandleRecordMessage(fields); }
/// <summary> /// This method highly relies on the fact that the session is not threadsafe and could only be used in a single thread /// as if two threads trying to modify the message size, then we might /// 1. force to pull all instead of streaming records /// 2. lose some records as only one record is buffered in result builder on client. /// </summary> public void Receive(IMessageResponseHandler responseHandler, int unhandledMessageSize = 0) { while (responseHandler.UnhandledMessageSize > unhandledMessageSize || (responseHandler.HasError && responseHandler.UnhandledMessageSize > 0) /*if error happens, then just drain the whole unhandledMessage queue*/) { ReceiveOne(responseHandler); //Read 1 message //Send to handler } }
public void Send(IEnumerable <IRequestMessage> messages, IMessageResponseHandler responseHandler) { foreach (var message in messages) { _writer.Write(message); _config.Logger?.Debug("C: ", message); } _writer.Flush(); Receive(responseHandler); }
public SocketConnection(ISocketClient socketClient, IAuthToken authToken, ILogger logger, IMessageResponseHandler messageResponseHandler = null) { Throw.ArgumentNullException.IfNull(socketClient, nameof(socketClient)); _responseHandler = messageResponseHandler ?? new MessageResponseHandler(logger); _client = socketClient; Task.Run(() => _client.Start()).Wait(); // add init requestMessage by default Init(authToken); }
public SocketConnection(ISocketClient socketClient, IAuthToken authToken, ILogger logger, IMessageResponseHandler messageResponseHandler = null) { Throw.ArgumentNullException.IfNull(socketClient, nameof(socketClient)); _messageHandler = messageResponseHandler ?? new MessageResponseHandler(logger); _client = socketClient; Task.Run(() => _client.Start()).Wait(); // add init requestMessage by default Enqueue(new InitMessage("neo4j-dotnet/1.0.0", authToken.AsDictionary())); }
/// <summary> /// Perform failure action if error /// </summary> public void ReceiveOne(IMessageResponseHandler responseHandler, Action onFailureAction) { if (responseHandler.UnhandledMessageSize == 0) { return; } ReceiveOne(responseHandler); if (responseHandler.HasError) { onFailureAction.Invoke(); } }
public SocketConnection(Uri uri, ConnectionSettings connectionSettings, BufferSettings bufferSettings, IConnectionListener metricsListener = null, IDriverLogger logger = null) { _id = $"conn-{UniqueIdGenerator.GetId()}"; _logger = new PrefixLogger(logger, FormatPrefix(_id)); _client = new SocketClient(uri, connectionSettings.SocketSettings, bufferSettings, metricsListener, _logger); _authToken = connectionSettings.AuthToken; _userAgent = connectionSettings.UserAgent; Server = new ServerInfo(uri); _responseHandler = new MessageResponseHandler(_logger); }
private void ProcessMessage(IMessageResponseHandler responseHandler) { var message = _packStreamReader.Read(); if (message is IResponseMessage response) { response.Dispatch(responseHandler); } else { throw new ProtocolException($"Unknown response message type {message.GetType().FullName}"); } }
internal SocketConnection(ISocketClient socketClient, IAuthToken authToken, string userAgent, ILogger logger, IServerInfo server, IMessageResponseHandler messageResponseHandler = 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; _logger = logger; _responseHandler = messageResponseHandler ?? new MessageResponseHandler(logger); }
// for test only internal SocketConnection(ISocketClient socketClient, IAuthToken authToken, string userAgent, IDriverLogger logger, IServerInfo server, IMessageResponseHandler messageResponseHandler = 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 = $"conn-{UniqueIdGenerator.GetId()}"; _logger = new PrefixLogger(logger, FormatPrefix(_id)); _responseHandler = messageResponseHandler ?? new MessageResponseHandler(logger); }
public void ReceiveOne(IMessageResponseHandler responseHandler) { try { _reader.Read(responseHandler); } catch (Exception ex) { _logger?.Error("Unable to unpack message from server, connection has been terminated.", ex); Task.Run(() => Stop()).Wait(); throw; } if (responseHandler.HasProtocolViolationError) { Task.Run(() => Stop()).Wait(); throw responseHandler.Error; } }
public void ReceiveOne(IMessageResponseHandler responseHandler) { try { _boltProtocol.Reader.Read(responseHandler); } catch (Exception ex) { _logger?.Error($"Unable to read message from server {_uri}, connection will be terminated.", ex); Stop(); throw; } if (responseHandler.HasProtocolViolationError) { _logger?.Info($"Received bolt protocol error from server {_uri}, connection will be terminated.", responseHandler.Error); Stop(); throw responseHandler.Error; } }
public async Task ReceiveOneAsync(IMessageResponseHandler responseHandler) { try { await _boltProtocol.Reader.ReadAsync(responseHandler).ConfigureAwait(false); } catch (Exception ex) { _logger?.Error($"Unable to read message from server {_uri}, connection will be terminated.", ex); await StopAsync().ConfigureAwait(false); throw; } if (responseHandler.HasProtocolViolationError) { _logger?.Info($"Received bolt protocol error from server {_uri}, connection will be terminated.", responseHandler.Error); await StopAsync().ConfigureAwait(false); throw responseHandler.Error; } }
private void ReceiveOne(IMessageResponseHandler responseHandler) { try { _reader.Read(responseHandler); } catch (Exception ex) { _config.Logger.Error("Unable to unpack message from server, connection has been terminated.", ex); Task.Run(() => Stop()).Wait(); throw; } if (responseHandler.HasError) { if (responseHandler.Error.Code.ToLowerInvariant().Contains("clienterror.request")) { Task.Run(() => Stop()).Wait(); throw responseHandler.Error; } } }
private void UnpackSuccessMessage(IMessageResponseHandler responseHandler) { var map = UnpackMap(); responseHandler.HandleSuccessMessage(map); }
internal static SocketConnection NewSocketConnection(ISocketClient socketClient = null, IMessageResponseHandler handler = null, IServerInfo server = null) { socketClient = socketClient ?? SocketClient; server = server ?? Server; return(new SocketConnection(socketClient, AuthToken, UserAgent, Logger, server, handler)); }
public void Dispatch(IMessageResponseHandler messageResponseHandler) { messageResponseHandler.HandleSuccessMessage(_meta); }
public void Dispatch(IMessageResponseHandler messageResponseHandler) { messageResponseHandler.HandleIgnoredMessage(); }
public void Dispatch(IMessageResponseHandler messageResponseHandler) { messageResponseHandler.HandleFailureMessage(Code, Message); }
public void Read(IMessageResponseHandler responseHandler) { var messages = _chunkReader.ReadNextMessages(_bufferStream); ConsumeMessages(responseHandler, messages); }
private void UnpackIgnoredMessage(IMessageResponseHandler responseHandler) { responseHandler.HandleIgnoredMessage(); }