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