public void ShouldNotReadLastMessageWhenPadding()
{
const int msgLength = 1;
int frameLength = HEADER_LENGTH + msgLength;
int alignedFrameLength = BitUtil.Align(frameLength, FrameDescriptor.FRAME_ALIGNMENT);
int frameOffset = TERM_BUFFER_CAPACITY - alignedFrameLength;
long startingPosition = LogBufferDescriptor.ComputePosition(
INITIAL_TERM_ID, frameOffset, POSITION_BITS_TO_SHIFT, INITIAL_TERM_ID);
A.CallTo(() => termBuffer.GetIntVolatile(frameOffset)).Returns(frameLength);
A.CallTo(() => termBuffer.GetShort(FrameDescriptor.TypeOffset(frameOffset)))
.Returns((short)FrameDescriptor.PADDING_FRAME_TYPE);
A.CallTo(() => subscriberPosition.GetVolatile()).Returns(startingPosition);
int readOutcome = TermReader.Read(
termBuffer,
frameOffset,
handler,
int.MaxValue,
header,
errorHandler,
startingPosition,
subscriberPosition);
Assert.AreEqual(0, readOutcome);
A.CallTo(() => termBuffer.GetIntVolatile(frameOffset)).MustHaveHappened()
.Then(A.CallTo(() => subscriberPosition.SetOrdered(TERM_BUFFER_CAPACITY)).MustHaveHappened());
A.CallTo(() => handler.OnFragment(A <UnsafeBuffer> ._, A <int> ._, A <int> ._, A <Header> ._))
.MustNotHaveHappened();
}
public void ShouldReadMultipleMessages()
{
const int msgLength = 1;
int frameLength = HEADER_LENGTH + msgLength;
int alignedFrameLength = BitUtil.Align(frameLength, FrameDescriptor.FRAME_ALIGNMENT);
const int termOffset = 0;
A.CallTo(() => termBuffer.GetIntVolatile(0)).Returns(frameLength);
A.CallTo(() => termBuffer.GetIntVolatile(alignedFrameLength)).Returns(frameLength);
A.CallTo(() => termBuffer.GetShort(A <int> ._)).Returns((short)HeaderFlyweight.HDR_TYPE_DATA);
int readOutcome = TermReader.Read(termBuffer, termOffset, handler, int.MaxValue, header, errorHandler, 0,
subscriberPosition);
Assert.AreEqual(2, readOutcome);
A.CallTo(() => termBuffer.GetIntVolatile(0)).MustHaveHappened()
.Then(A.CallTo(() => handler.OnFragment(termBuffer, HEADER_LENGTH, msgLength, A <Header> ._))
.MustHaveHappened())
.Then(A.CallTo(() => termBuffer.GetIntVolatile(alignedFrameLength)).MustHaveHappened())
.Then(A.CallTo(() =>
handler.OnFragment(termBuffer, alignedFrameLength + HEADER_LENGTH, msgLength, A <Header> ._))
.MustHaveHappened())
.Then(A.CallTo(() => subscriberPosition.SetOrdered(alignedFrameLength * 2)).MustHaveHappened());
}
public void ShouldPackPaddingAndOffsetIntoResultingStatus()
{
const int offset = 77;
const int fragmentsRead = 999;
long scanOutcome = TermReader.Pack(offset, fragmentsRead);
Assert.That(TermReader.Offset(scanOutcome), Is.EqualTo(offset));
Assert.That(TermReader.FragmentsRead(scanOutcome), Is.EqualTo(fragmentsRead));
}
/// <summary>
/// Poll messages starting from _subscriberPosition and invoke OnAppendHandlerOld event
/// </summary>
private long Poll()
{
var subscriberIndex = IndexByPosition(_subscriberPosition, _positionBitsToShift);
int termOffset = (int)_subscriberPosition & _termLengthMask;
var termBuffer = _logBuffers.Buffers[subscriberIndex];
long outcome = TermReader.Read(termBuffer, termOffset, OnAppend, 10, OnError);
UpdatePosition(termOffset, TermReader.Offset(outcome));
return(outcome & 0xFFFFFFFFL);
}
public void ShouldNotReadPastTail()
{
const int termOffset = 0;
long readOutcome = TermReader.Read(termBuffer, termOffset, handler, int.MaxValue, header, errorHandler);
Assert.That(TermReader.FragmentsRead(readOutcome), Is.EqualTo(0));
Assert.That(TermReader.Offset(readOutcome), Is.EqualTo(termOffset));
A.CallTo(() => termBuffer.GetIntVolatile(0)).MustHaveHappened();
A.CallTo(() => handler(A <IDirectBuffer> ._, A <int> ._, A <int> ._, A <Header> ._)).MustNotHaveHappened();
}
public void ShouldNotReadPastTail()
{
const int termOffset = 0;
int readOutcome = TermReader.Read(termBuffer, termOffset, handler, int.MaxValue, header, errorHandler, 0, subscriberPosition);
Assert.That(TermReader.FragmentsRead(readOutcome), Is.EqualTo(0));
Assert.That(TermReader.Offset(readOutcome), Is.EqualTo(termOffset));
A.CallTo(() => subscriberPosition.SetOrdered(A <long> ._)).MustNotHaveHappened();
A.CallTo(() => termBuffer.GetIntVolatile(0)).MustHaveHappened();
A.CallTo(() => handler.OnFragment(A <UnsafeBuffer> ._, A <int> ._, A <int> ._, A <Header> ._)).MustNotHaveHappened();
}
///// <summary>
///// The <seealso cref="FileChannel"/> to the raw log of the Image.
///// </summary>
///// <returns> the <seealso cref="FileChannel"/> to the raw log of the Image. </returns>
//public FileChannel FileChannel()
//{
// return logBuffers.FileChannel();
//}
/// <summary>
/// Poll for new messages in a stream. If new messages are found beyond the last consumed position then they
/// will be delivered to the <seealso cref="FragmentHandler"/> up to a limited number of fragments as specified.
///
/// To assemble messages that span multiple fragments then use <seealso cref="FragmentAssembler"/>.
/// </summary>
/// <param name="fragmentHandler"> to which message fragments are delivered. </param>
/// <param name="fragmentLimit"> for the number of fragments to be consumed during one polling operation. </param>
/// <returns> the number of fragments that have been consumed. </returns>
/// <seealso cref="FragmentAssembler" />
public virtual int Poll(FragmentHandler fragmentHandler, int fragmentLimit)
{
if (_isClosed)
{
return(0);
}
var position = _subscriberPosition.Get();
var termOffset = (int)position & _termLengthMask;
var termBuffer = ActiveTermBuffer(position);
var outcome = TermReader.Read(termBuffer, termOffset, fragmentHandler, fragmentLimit, _header, _errorHandler);
UpdatePosition(position, termOffset, TermReader.Offset(outcome));
return(TermReader.FragmentsRead(outcome));
}
/**
* Poll for new messages in a stream. If new messages are found beyond the last consumed position then they
* will be delivered to the {@link FragmentHandler} up to a limited number of fragments as specified.
*
* To assemble messages that span multiple fragments then use {@link FragmentAssembler}.
*
* @param fragmentHandler to which message fragments are delivered.
* @param fragmentLimit for the number of fragments to be consumed during one polling operation.
* @return the number of fragments that have been consumed.
* @see FragmentAssembler
*/
public int poll(FragmentHandler fragmentHandler, int fragmentLimit)
{
if (isClosed)
{
return(0);
}
long position = subscriberPosition.get();
int termOffset = (int)position & _termLengthMask;
DirectBuffer termBuffer = activeTermBuffer(position);
long outcome = TermReader.Read(termBuffer, termOffset, fragmentHandler, fragmentLimit, header, errorHandler);
updatePosition(position, termOffset, TermReader.Offset(outcome));
return(TermReader.FragmentsRead(outcome));
}
public void ShouldReadOneLimitedMessage()
{
const int msgLength = 1;
int frameLength = HEADER_LENGTH + msgLength;
const int termOffset = 0;
A.CallTo(() => termBuffer.GetIntVolatile(A <int> ._))
.Returns(frameLength);
A.CallTo(() => termBuffer.GetShort(A <int> ._))
.Returns((short)HeaderFlyweight.HDR_TYPE_DATA);
long readOutcome = TermReader.Read(termBuffer, termOffset, handler, 1, header, errorHandler);
Assert.That(TermReader.FragmentsRead(readOutcome), Is.EqualTo(1));
A.CallTo(() => termBuffer.GetIntVolatile(0)).MustHaveHappened()
.Then(A.CallTo(() => handler(termBuffer, HEADER_LENGTH, msgLength, A <Header> ._)).MustHaveHappened());
}
public void ShouldNotReadLastMessageWhenPadding()
{
const int msgLength = 1;
int frameLength = HEADER_LENGTH + msgLength;
int alignedFrameLength = BitUtil.Align(frameLength, FrameDescriptor.FRAME_ALIGNMENT);
int frameOffset = TERM_BUFFER_CAPACITY - alignedFrameLength;
A.CallTo(() => termBuffer.GetIntVolatile(frameOffset)).Returns(frameLength);
A.CallTo(() => termBuffer.GetShort(FrameDescriptor.TypeOffset(frameOffset))).Returns((short)FrameDescriptor.PADDING_FRAME_TYPE);
long readOutcome = TermReader.Read(termBuffer, frameOffset, handler, int.MaxValue, header, errorHandler);
Assert.That(TermReader.FragmentsRead(readOutcome), Is.EqualTo(0));
Assert.That(TermReader.Offset(readOutcome), Is.EqualTo(TERM_BUFFER_CAPACITY));
A.CallTo(() => termBuffer.GetIntVolatile(frameOffset)).MustHaveHappened();
A.CallTo(() => handler(A <IDirectBuffer> ._, A <int> ._, A <int> ._, A <Header> ._)).MustNotHaveHappened();
}
public void ShouldReadLastMessage()
{
const int msgLength = 1;
int frameLength = HEADER_LENGTH + msgLength;
int alignedFrameLength = BitUtil.Align(frameLength, FrameDescriptor.FRAME_ALIGNMENT);
int frameOffset = TERM_BUFFER_CAPACITY - alignedFrameLength;
A.CallTo(() => termBuffer.GetIntVolatile(frameOffset)).Returns(frameLength);
A.CallTo(() => termBuffer.GetShort(FrameDescriptor.TypeOffset(frameOffset))).Returns((short)HeaderFlyweight.HDR_TYPE_DATA);
long readOutcome = TermReader.Read(termBuffer, frameOffset, handler, int.MaxValue, header, errorHandler);
Assert.That(TermReader.FragmentsRead(readOutcome), Is.EqualTo(1));
Assert.That(TermReader.Offset(readOutcome), Is.EqualTo(TERM_BUFFER_CAPACITY));
A.CallTo(() => termBuffer.GetIntVolatile(frameOffset)).MustHaveHappened()
.Then(A.CallTo(() => handler(termBuffer, frameOffset + HEADER_LENGTH, msgLength, A <Header> ._)).MustHaveHappened());
}
/// <summary>
/// Poll for new messages in a stream. If new messages are found beyond the last consumed position then they
/// will be delivered to the <seealso cref="FragmentHandler"/> up to a limited number of fragments as specified.
///
/// Use a <see cref="FragmentAssembler"/> to assemble messages which span multiple fragments.
/// </summary>
/// <param name="fragmentHandler"> to which message fragments are delivered. </param>
/// <param name="fragmentLimit"> for the number of fragments to be consumed during one polling operation. </param>
/// <returns> the number of fragments that have been consumed. </returns>
/// <seealso cref="FragmentAssembler" />
/// <seealso cref="ImageFragmentAssembler" />
public int Poll(IFragmentHandler fragmentHandler, int fragmentLimit)
{
if (_isClosed)
{
return(0);
}
var position = _subscriberPosition.Get();
return(TermReader.Read(
ActiveTermBuffer(position),
(int)position & _termLengthMask,
fragmentHandler,
fragmentLimit,
_header,
_errorHandler,
position,
_subscriberPosition));
}
public void ShouldReadOneLimitedMessage()
{
const int msgLength = 1;
int frameLength = HEADER_LENGTH + msgLength;
int alignedFrameLength = BitUtil.Align(frameLength, FrameDescriptor.FRAME_ALIGNMENT);
const int termOffset = 0;
A.CallTo(() => termBuffer.GetIntVolatile(A <int> ._))
.Returns(frameLength);
A.CallTo(() => termBuffer.GetShort(A <int> ._))
.Returns((short)HeaderFlyweight.HDR_TYPE_DATA);
int readOutcome = TermReader.Read(termBuffer, termOffset, handler, 1, header, errorHandler, 0, subscriberPosition);
Assert.That(readOutcome, Is.EqualTo(1));
A.CallTo(() => termBuffer.GetIntVolatile(0)).MustHaveHappened()
.Then(A.CallTo(() => handler(termBuffer, HEADER_LENGTH, msgLength, A <Header> ._)).MustHaveHappened())
.Then(A.CallTo(() => subscriberPosition.SetOrdered(alignedFrameLength)).MustHaveHappened());
}
