//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldLogContentOfTheMessageOnIOError() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldLogContentOfTheMessageOnIOError()
{
BoltConnection connection = mock(typeof(BoltConnection));
BoltResponseMessageWriter responseMessageHandler = mock(typeof(BoltResponseMessageWriter));
BoltRequestMessageReader requestMessageReader = new BoltRequestMessageReaderV1(connection, responseMessageHandler, NullLogService.Instance);
LogService logService = mock(typeof(LogService));
Log log = mock(typeof(Log));
when(logService.GetInternalLog(typeof(MessageDecoder))).thenReturn(log);
_channel = new EmbeddedChannel(new MessageDecoder(PackerUnderTest.newUnpacker, requestMessageReader, logService));
sbyte invalidMessageSignature = sbyte.MaxValue;
sbyte[] messageBytes = PackMessageWithSignature(invalidMessageSignature);
try
{
_channel.writeInbound(Unpooled.wrappedBuffer(messageBytes));
fail("Exception expected");
}
catch (Exception)
{
}
AssertMessageHexDumpLogged(log, messageBytes);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static org.neo4j.bolt.messaging.BoltResponseMessageWriter newResponseHandlerMock(boolean fatalError, Throwable error) throws Exception
private static BoltResponseMessageWriter NewResponseHandlerMock(bool fatalError, Exception error)
{
BoltResponseMessageWriter handler = NewResponseHandlerMock();
doThrow(error).when(handler).write(any(typeof(FailureMessage)));
return(handler);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static org.neo4j.logging.AssertableLogProvider emulateFailureWritingError(org.neo4j.bolt.runtime.Neo4jError error, Throwable errorDuringWrite) throws Exception
private static AssertableLogProvider EmulateFailureWritingError(Neo4jError error, Exception errorDuringWrite)
{
AssertableLogProvider logProvider = new AssertableLogProvider();
BoltResponseMessageWriter responseHandler = NewResponseHandlerMock(error.Fatal, errorDuringWrite);
MessageProcessingHandler handler = new MessageProcessingHandler(responseHandler, mock(typeof(BoltConnection)), logProvider.GetLog("Test"));
handler.MarkFailed(error);
handler.OnFinish();
return(logProvider);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCallHaltOnUnexpectedFailures() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldCallHaltOnUnexpectedFailures()
{
// Given
BoltResponseMessageWriter msgWriter = NewResponseHandlerMock();
doThrow(new Exception("Something went horribly wrong")).when(msgWriter).write(any(typeof(SuccessMessage)));
BoltConnection connection = mock(typeof(BoltConnection));
MessageProcessingHandler handler = new MessageProcessingHandler(msgWriter, connection, mock(typeof(Log)));
// When
handler.OnFinish();
// Then
verify(connection).stop();
}
private void PublishError(BoltResponseMessageWriter messageWriter, Neo4jError error)
{
try
{
if (error.Fatal)
{
messageWriter.Write(new FatalFailureMessage(error.Status(), error.Message()));
}
else
{
messageWriter.Write(new FailureMessage(error.Status(), error.Message()));
}
}
catch (PackOutputClosedException e)
{
// Can't write error to the client, because the connection is closed.
// Very likely our error is related to the connection being closed.
// If the error is that the transaction was terminated, then the error is a side-effect of
// us cleaning up stuff that was running when the client disconnected. Log a warning without
// stack trace to highlight clients are disconnecting while stuff is running:
if (_clientMidOpDisconnectErrors.Contains(error.Status()))
{
Log.warn("Client %s disconnected while query was running. Session has been cleaned up. " + "This can be caused by temporary network problems, but if you see this often, " + "ensure your applications are properly waiting for operations to complete before exiting.", e.ClientAddress());
return;
}
// If the error isn't that the tx was terminated, log it to the console for debugging. It's likely
// there are other "ok" errors that we can whitelist into the conditional above over time.
Log.warn("Unable to send error back to the client. " + e.Message, error.Cause());
}
catch (Exception t)
{
// some unexpected error happened while writing exception back to the client
// log it together with the original error being suppressed
t.addSuppressed(error.Cause());
Log.error("Unable to send error back to the client", t);
}
}
public MessageProcessingHandler(BoltResponseMessageWriter messageWriter, BoltConnection connection, Log logger)
{
this.MessageWriter = messageWriter;
this.Connection = connection;
this.Log = logger;
}
private static BoltResponseHandler NewSimpleResponseHandler(BoltResponseMessageWriter responseMessageWriter, BoltConnection connection, LogService logService)
{
return(new MessageProcessingHandler(responseMessageWriter, connection, InternalLog(logService)));
}
private static IList <RequestMessageDecoder> BuildDecoders(BoltConnection connection, BoltResponseMessageWriter responseMessageWriter, LogService logService)
{
BoltResponseHandler resultHandler = new ResultHandler(responseMessageWriter, connection, InternalLog(logService));
BoltResponseHandler defaultHandler = NewSimpleResponseHandler(responseMessageWriter, connection, logService);
return(Arrays.asList(new HelloMessageDecoder(defaultHandler), new RunMessageDecoder(defaultHandler), new DiscardAllMessageDecoder(resultHandler), new PullAllMessageDecoder(resultHandler), new BeginMessageDecoder(defaultHandler), new CommitMessageDecoder(resultHandler), new RollbackMessageDecoder(resultHandler), new ResetMessageDecoder(connection, defaultHandler), new GoodbyeMessageDecoder(connection, defaultHandler)
));
}
public BoltRequestMessageReaderV3(BoltConnection connection, BoltResponseMessageWriter responseMessageWriter, LogService logService) : base(connection, NewSimpleResponseHandler(responseMessageWriter, connection, logService), BuildDecoders(connection, responseMessageWriter, logService))
{
}
private static IList <RequestMessageDecoder> BuildDecoders(BoltConnection connection, BoltResponseMessageWriter responseMessageWriter, LogService logService)
{
BoltResponseHandler initHandler = NewSimpleResponseHandler(connection, responseMessageWriter, logService);
BoltResponseHandler runHandler = NewSimpleResponseHandler(connection, responseMessageWriter, logService);
BoltResponseHandler resultHandler = new ResultHandler(responseMessageWriter, connection, InternalLog(logService));
BoltResponseHandler defaultHandler = NewSimpleResponseHandler(connection, responseMessageWriter, logService);
return(Arrays.asList(new InitMessageDecoder(initHandler), new AckFailureMessageDecoder(defaultHandler), new ResetMessageDecoder(connection, defaultHandler), new RunMessageDecoder(runHandler), new DiscardAllMessageDecoder(resultHandler), new PullAllMessageDecoder(resultHandler)
));
}
