/** * Get whether the log is considered connected or not by the driver. * * @param metadataBuffer containing the meta data. * @return whether the log is considered connected or not by the driver. */ public static boolean isConnected(final UnsafeBuffer metadataBuffer) { return metadataBuffer.getIntVolatile(LOG_IS_CONNECTED_OFFSET) == 1; }
/** * Get the value of the active term count used by the producer of this log. Consumers may have a different * active term count if they are running behind. The read is done with volatile semantics. * * @param metadataBuffer containing the meta data. * @return the value of the active term count used by the producer of this log. */ public static int activeTermCount(final UnsafeBuffer metadataBuffer) { return metadataBuffer.getIntVolatile(LOG_ACTIVE_TERM_COUNT_OFFSET); }
public int memberId() { return buffer.getIntVolatile(MarkFileHeaderDecoder.memberIdEncodingOffset()); }
@Test public void shouldTakeNoActionIfMessageNonCommittedAfterScan() { final int messageLength = HEADER_LENGTH * 4; final int termOffset = 0; final int tailOffset = messageLength * 2; when(mockTermBuffer.getIntVolatile(termOffset)) .thenReturn(0) .thenReturn(-messageLength); when(mockTermBuffer.getIntVolatile(messageLength)) .thenReturn(messageLength); assertThat(TermUnblocker.unblock( mockLogMetaDataBuffer, mockTermBuffer, termOffset, tailOffset, TERM_ID), is(NO_ACTION)); }
@Test public void shouldReportNoGapWhenHwmIsInPadding() { final int paddingLength = align(HEADER_LENGTH, FRAME_ALIGNMENT) * 2; final int tail = LOG_BUFFER_CAPACITY - paddingLength; final int highWaterMark = LOG_BUFFER_CAPACITY - paddingLength + HEADER_LENGTH; when(termBuffer.getIntVolatile(tail)).thenReturn(paddingLength); when(termBuffer.getIntVolatile(tail + HEADER_LENGTH)).thenReturn(0); assertThat(TermGapScanner.scanForGap(termBuffer, TERM_ID, tail, highWaterMark, gapHandler), is(LOG_BUFFER_CAPACITY)); verifyZeroInteractions(gapHandler); } }
@Test public void shouldTakeNoActionToEndOfPartitionIfMessageCompleteAfterScan() { final int messageLength = HEADER_LENGTH * 4; final int termOffset = TERM_BUFFER_CAPACITY - messageLength; final int tailOffset = TERM_BUFFER_CAPACITY; when(mockTermBuffer.getIntVolatile(termOffset)) .thenReturn(0) .thenReturn(messageLength); assertThat(TermUnblocker.unblock( mockLogMetaDataBuffer, mockTermBuffer, termOffset, tailOffset, TERM_ID), is(NO_ACTION)); }
@Test public void shouldTakeNoActionToEndOfPartitionIfMessageNonCommittedAfterScan() { final int messageLength = HEADER_LENGTH * 4; final int termOffset = TERM_BUFFER_CAPACITY - messageLength; final int tailOffset = TERM_BUFFER_CAPACITY; when(mockTermBuffer.getIntVolatile(termOffset)) .thenReturn(0) .thenReturn(-messageLength); assertThat(TermUnblocker.unblock( mockLogMetaDataBuffer, mockTermBuffer, termOffset, tailOffset, TERM_ID), is(NO_ACTION)); }
@Test public void shouldReportSingleGapWhenBufferIsFull() { final int tail = LOG_BUFFER_CAPACITY - (align(HEADER_LENGTH, FRAME_ALIGNMENT) * 2); final int highWaterMark = LOG_BUFFER_CAPACITY; when(termBuffer.getIntVolatile(tail - align(HEADER_LENGTH, FRAME_ALIGNMENT))).thenReturn(HEADER_LENGTH); when(termBuffer.getIntVolatile(tail)).thenReturn(0); when(termBuffer.getIntVolatile(highWaterMark - align(HEADER_LENGTH, FRAME_ALIGNMENT))) .thenReturn(HEADER_LENGTH); assertThat(TermGapScanner.scanForGap(termBuffer, TERM_ID, tail, highWaterMark, gapHandler), is(tail)); verify(gapHandler).onGap(TERM_ID, tail, align(HEADER_LENGTH, FRAME_ALIGNMENT)); }
@Test public void shouldReportSingleGapWhenBufferNotFull() { final int tail = align(HEADER_LENGTH, FRAME_ALIGNMENT); final int highWaterMark = FRAME_ALIGNMENT * 3; when(termBuffer.getIntVolatile(tail - align(HEADER_LENGTH, FRAME_ALIGNMENT))).thenReturn(HEADER_LENGTH); when(termBuffer.getIntVolatile(tail)).thenReturn(0); when(termBuffer.getIntVolatile(highWaterMark - align(HEADER_LENGTH, FRAME_ALIGNMENT))) .thenReturn(HEADER_LENGTH); assertThat(TermGapScanner.scanForGap(termBuffer, TERM_ID, tail, highWaterMark, gapHandler), is(tail)); verify(gapHandler).onGap(TERM_ID, tail, align(HEADER_LENGTH, FRAME_ALIGNMENT)); }
@Test public void shouldTakeNoActionWhenMessageIsComplete() { final int termOffset = 0; final int tailOffset = TERM_BUFFER_CAPACITY; when(mockTermBuffer.getIntVolatile(termOffset)).thenReturn(HEADER_LENGTH); assertThat(TermUnblocker.unblock( mockLogMetaDataBuffer, mockTermBuffer, termOffset, tailOffset, TERM_ID), is(NO_ACTION)); }
@Test public void shouldNotReadPastTail() { final int termOffset = 0; final int readOutcome = TermReader.read( termBuffer, termOffset, handler, Integer.MAX_VALUE, header, errorHandler, 0, subscriberPosition); assertThat(readOutcome, is(0)); verify(subscriberPosition, never()).setOrdered(anyLong()); verify(termBuffer).getIntVolatile(0); verify(handler, never()).onFragment(any(), anyInt(), anyInt(), any()); }
@Test public void shouldReadBlockOfTwoMessages() { final int offset = 0; final int limit = termBuffer.capacity(); final int messageLength = 50; final int alignedMessageLength = BitUtil.align(messageLength, FRAME_ALIGNMENT); when(termBuffer.getIntVolatile(lengthOffset(offset))).thenReturn(messageLength); when(termBuffer.getShort(typeOffset(offset))).thenReturn((short)HDR_TYPE_DATA); when(termBuffer.getIntVolatile(lengthOffset(alignedMessageLength))).thenReturn(messageLength); when(termBuffer.getShort(typeOffset(alignedMessageLength))).thenReturn((short)HDR_TYPE_DATA); final int newOffset = TermBlockScanner.scan(termBuffer, offset, limit); assertThat(newOffset, is(alignedMessageLength * 2)); }
@Test public void shouldFailToReadFirstMessageBecauseOfLimit() { final int offset = 0; final int messageLength = 50; final int alignedMessageLength = BitUtil.align(messageLength, FRAME_ALIGNMENT); final int limit = alignedMessageLength - 1; when(termBuffer.getIntVolatile(lengthOffset(offset))).thenReturn(messageLength); when(termBuffer.getShort(typeOffset(offset))).thenReturn((short)HDR_TYPE_DATA); final int newOffset = TermBlockScanner.scan(termBuffer, offset, limit); assertThat(newOffset, is(offset)); }
@Test public void shouldScanForwardForNextNonCommittedMessage() { final int messageLength = HEADER_LENGTH * 4; final int termOffset = 0; final int tailOffset = messageLength * 2; when(mockTermBuffer.getIntVolatile(messageLength)).thenReturn(-messageLength); assertThat(TermUnblocker.unblock( mockLogMetaDataBuffer, mockTermBuffer, termOffset, tailOffset, TERM_ID), is(UNBLOCKED)); final InOrder inOrder = inOrder(mockTermBuffer); inOrder.verify(mockTermBuffer).putShort(typeOffset(termOffset), (short)HDR_TYPE_PAD, LITTLE_ENDIAN); inOrder.verify(mockTermBuffer).putInt(termOffsetOffset(termOffset), termOffset, LITTLE_ENDIAN); inOrder.verify(mockTermBuffer).putIntOrdered(termOffset, messageLength); }
@Test public void shouldReportGapAtBeginningOfBuffer() { final int frameOffset = align(HEADER_LENGTH * 3, FRAME_ALIGNMENT); final int highWaterMark = frameOffset + align(HEADER_LENGTH, FRAME_ALIGNMENT); when(termBuffer.getIntVolatile(frameOffset)).thenReturn(HEADER_LENGTH); assertThat(TermGapScanner.scanForGap(termBuffer, TERM_ID, 0, highWaterMark, gapHandler), is(0)); verify(gapHandler).onGap(TERM_ID, 0, frameOffset); }
@Test public void shouldReadOneMessageOnLimit() { final int offset = 0; final int messageLength = 50; final int alignedMessageLength = BitUtil.align(messageLength, FRAME_ALIGNMENT); when(termBuffer.getIntVolatile(lengthOffset(offset))).thenReturn(messageLength); when(termBuffer.getShort(typeOffset(offset))).thenReturn((short)HDR_TYPE_DATA); final int newOffset = TermBlockScanner.scan(termBuffer, offset, alignedMessageLength); assertThat(newOffset, is(alignedMessageLength)); }
@Test public void shouldReadFirstMessage() { final int offset = 0; final int limit = termBuffer.capacity(); final int messageLength = 50; final int alignedMessageLength = BitUtil.align(messageLength, FRAME_ALIGNMENT); when(termBuffer.getIntVolatile(lengthOffset(offset))).thenReturn(messageLength); when(termBuffer.getShort(typeOffset(offset))).thenReturn((short)HDR_TYPE_DATA); final int newOffset = TermBlockScanner.scan(termBuffer, offset, limit); assertThat(newOffset, is(alignedMessageLength)); }
@Test public void shouldScanLastFrameInBuffer() { final int alignedFrameLength = align(HEADER_LENGTH * 2, FRAME_ALIGNMENT); final int frameOffset = TERM_BUFFER_CAPACITY - alignedFrameLength; when(termBuffer.getIntVolatile(frameOffset)).thenReturn(alignedFrameLength); when(termBuffer.getShort(typeOffset(frameOffset))).thenReturn((short)HDR_TYPE_DATA); final long scanOutcome = TermScanner.scanForAvailability(termBuffer, frameOffset, MTU_LENGTH); assertThat(TermScanner.available(scanOutcome), is(alignedFrameLength)); assertThat(TermScanner.padding(scanOutcome), is(0)); }
@Test public void shouldNotUnblockWhenPositionHasCompleteMessage() { final int blockedOffset = HEADER_LENGTH * 4; final long blockedPosition = computePosition(TERM_ID_1, blockedOffset, positionBitsToShift, TERM_ID_1); final int activeIndex = indexByPosition(blockedPosition, positionBitsToShift); when(termBuffers[activeIndex].getIntVolatile(blockedOffset)).thenReturn(HEADER_LENGTH); assertFalse(LogBufferUnblocker.unblock(termBuffers, logMetaDataBuffer, blockedPosition, TERM_LENGTH)); final long rawTail = rawTailVolatile(logMetaDataBuffer); assertThat(computePosition(termId(rawTail), blockedOffset, positionBitsToShift, TERM_ID_1), is(blockedPosition)); }
@Test public void shouldUnblockWhenPositionHasNonCommittedMessageAndTailWithinTerm() { final int blockedOffset = HEADER_LENGTH * 4; final int messageLength = HEADER_LENGTH * 4; final long blockedPosition = computePosition(TERM_ID_1, blockedOffset, positionBitsToShift, TERM_ID_1); final int activeIndex = indexByPosition(blockedPosition, positionBitsToShift); when(termBuffers[activeIndex].getIntVolatile(blockedOffset)).thenReturn(-messageLength); assertTrue(LogBufferUnblocker.unblock(termBuffers, logMetaDataBuffer, blockedPosition, TERM_LENGTH)); final long rawTail = rawTailVolatile(logMetaDataBuffer); assertThat(computePosition(termId(rawTail), blockedOffset + messageLength, positionBitsToShift, TERM_ID_1), is(blockedPosition + messageLength)); }