/** * Compute the length of the cnc file and return it. * * @param totalLengthOfBuffers in bytes * @param alignment for file length to adhere to * @return cnc file length in bytes */ public static int computeCncFileLength(final int totalLengthOfBuffers, final int alignment) { return align(END_OF_METADATA_OFFSET + totalLengthOfBuffers, alignment); }
private int sourceIdentityOffset() { final int alignedLength = BitUtil.align(buffer.getInt(offset + LOG_FILE_NAME_OFFSET), SIZE_OF_INT); return LOG_FILE_NAME_OFFSET + SIZE_OF_INT + alignedLength; } }
private int labelOffset() { return KEY_LENGTH_OFFSET + SIZE_OF_INT + BitUtil.align(buffer.getInt(offset + KEY_LENGTH_OFFSET), SIZE_OF_INT); } }
long calculatePositionForMembershipChangeEvent(final String clusterMembers) { final int length = DataHeaderFlyweight.HEADER_LENGTH + MessageHeaderEncoder.ENCODED_LENGTH + MembershipChangeEventEncoder.BLOCK_LENGTH + MembershipChangeEventEncoder.clusterMembersHeaderLength() + clusterMembers.length(); return position() + BitUtil.align(length, FRAME_ALIGNMENT); }
private boolean appendAction(final ClusterAction action, final long nowMs) { final int length = DataHeaderFlyweight.HEADER_LENGTH + MessageHeaderEncoder.ENCODED_LENGTH + ClusterActionRequestEncoder.BLOCK_LENGTH; final long position = logPublisher.position() + BitUtil.align(length, FrameDescriptor.FRAME_ALIGNMENT); return logPublisher.appendClusterAction(leadershipTermId, position, nowMs, action); }
private int offsetOfMessage(final int offset) { return (offset - 1) * align(HEADER.capacity() + PAYLOAD.length, FRAME_ALIGNMENT); } }
private void prepMessagesAndListener( final Subscription recordingEvents, final int messageCount, final CountDownLatch streamConsumedLatch) { messageLengths = new int[messageCount]; for (int i = 0; i < messageCount; i++) { final int messageLength = 64 + rnd.nextInt(MAX_FRAGMENT_SIZE - 64) - HEADER_LENGTH; messageLengths[i] = messageLength + HEADER_LENGTH; totalDataLength += BitUtil.align(messageLengths[i], FrameDescriptor.FRAME_ALIGNMENT); } progressTracker = trackRecordingProgress(recordingEvents, streamConsumedLatch); }
@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)); }
/** * Get the current position to which the image has advanced on reading this message. * * @return the current position to which the image has advanced on reading this message. */ public final long position() { final int resultingOffset = BitUtil.align(termOffset() + frameLength(), FRAME_ALIGNMENT); return computePosition(termId(), resultingOffset, positionBitsToShift, initialTermId); }
@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 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); } }
@SuppressWarnings("unused") private void validateFragment(final DirectBuffer buffer, final int offset, final int length, final Header header) { assertThat(length, is(messageLengths[messageCount] - HEADER_LENGTH)); assertThat(buffer.getInt(offset), is(messageCount)); assertThat(buffer.getByte(offset + 4), is((byte)'z')); remaining -= BitUtil.align(messageLengths[messageCount], FrameDescriptor.FRAME_ALIGNMENT); messageCount++; }
@Test public void shouldFillSingleGap() { final int frameLength = 50; final int alignedFrameLength = BitUtil.align(frameLength, FRAME_ALIGNMENT); final int srcOffset = 0; final int tail = alignedFrameLength; final int termOffset = tail; final UnsafeBuffer packet = new UnsafeBuffer(ByteBuffer.allocateDirect(alignedFrameLength)); TermRebuilder.insert(termBuffer, termOffset, packet, alignedFrameLength); verify(termBuffer).putBytes( tail + HEADER_LENGTH, packet, srcOffset + HEADER_LENGTH, alignedFrameLength - HEADER_LENGTH); }
@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 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 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 shouldInsertLastFrameIntoBuffer() { final int frameLength = BitUtil.align(256, FRAME_ALIGNMENT); final int srcOffset = 0; final int tail = TERM_BUFFER_CAPACITY - frameLength; final int termOffset = tail; final UnsafeBuffer packet = new UnsafeBuffer(ByteBuffer.allocateDirect(frameLength)); packet.putShort(typeOffset(srcOffset), (short)PADDING_FRAME_TYPE, LITTLE_ENDIAN); packet.putInt(srcOffset, frameLength, LITTLE_ENDIAN); TermRebuilder.insert(termBuffer, termOffset, packet, frameLength); verify(termBuffer).putBytes( tail + HEADER_LENGTH, packet, srcOffset + HEADER_LENGTH, frameLength - HEADER_LENGTH); }