/** * Get the raw value of the tail for the given partition. * * @param metadataBuffer containing the tail counters. * @param partitionIndex for the tail counter. * @return the raw value of the tail for the current active partition. */ public static long rawTail(final UnsafeBuffer metadataBuffer, final int partitionIndex) { return metadataBuffer.getLong(TERM_TAIL_COUNTERS_OFFSET + (SIZE_OF_LONG * partitionIndex)); }
@Test public void shouldInsertPaddingAndWriteToBuffer() { final int padding = 200; final int messageLength = 400; final long tail = 2 * CAPACITY - padding; final long head = tail; // free space is (200 + 300) more than message length (400) // but contiguous space (300) is less than message length (400) final long headCache = CAPACITY + 300; when(buffer.getLongVolatile(HEAD_COUNTER_INDEX)).thenReturn(head); when(buffer.getLong(TAIL_COUNTER_INDEX)).thenReturn(tail); when(buffer.getLong(HEAD_COUNTER_CACHE_INDEX)).thenReturn(headCache); final UnsafeBuffer srcBuffer = new UnsafeBuffer(new byte[messageLength]); assertTrue(ringBuffer.write(MSG_TYPE_ID, srcBuffer, 0, messageLength)); } }
/** * Get the value of the correlation ID for this log relating to the command which created it. * * @param metadataBuffer containing the meta data. * @return the value of the correlation ID used for this log. */ public static long correlationId(final UnsafeBuffer metadataBuffer) { return metadataBuffer.getLong(LOG_CORRELATION_ID_OFFSET); }
@Test public void shouldRejectWriteWhenBufferFull() { final int length = 8; final long head = 0L; final long tail = head + CAPACITY; when(buffer.getLongVolatile(HEAD_COUNTER_INDEX)).thenReturn(head); when(buffer.getLong(TAIL_COUNTER_INDEX)).thenReturn(tail); final UnsafeBuffer srcBuffer = new UnsafeBuffer(new byte[1024]); final int srcIndex = 0; assertFalse(ringBuffer.write(MSG_TYPE_ID, srcBuffer, srcIndex, length)); verify(buffer, never()).putLongOrdered(anyInt(), anyInt()); }
/** * Get the value stored in the reserve space at the end of a data frame header. * <p> * Note: The value is in {@link ByteOrder#LITTLE_ENDIAN} format. * * @return the value stored in the reserve space at the end of a data frame header. * @see io.aeron.protocol.DataHeaderFlyweight */ public final long reservedValue() { return buffer.getLong(RESERVED_VALUE_OFFSET, LITTLE_ENDIAN); }
@Test public void shouldRejectWriteWhenInsufficientSpace() { final int length = 200; final long head = 0L; final long tail = head + (CAPACITY - align(length - ALIGNMENT, ALIGNMENT)); when(buffer.getLongVolatile(HEAD_COUNTER_INDEX)).thenReturn(head); when(buffer.getLong(TAIL_COUNTER_INDEX)).thenReturn(tail); final UnsafeBuffer srcBuffer = new UnsafeBuffer(new byte[1024]); final int srcIndex = 0; assertFalse(ringBuffer.write(MSG_TYPE_ID, srcBuffer, srcIndex, length)); verify(buffer, never()).putBytes(anyInt(), eq(srcBuffer), anyInt(), anyInt()); verify(buffer, never()).putLong(anyInt(), anyInt()); verify(buffer, never()).putLongOrdered(anyInt(), anyInt()); verify(buffer, never()).putIntOrdered(anyInt(), anyInt()); }
public long timestampWeak() { return buffer.getLong(timestampFieldOffset); }
@Test public void shouldLateJoinTransmission() { final int length = 8; final int recordLength = length + HEADER_LENGTH; final int recordLengthAligned = align(recordLength, RECORD_ALIGNMENT); final long tail = (CAPACITY * 3L) + HEADER_LENGTH + recordLengthAligned; final long latestRecord = tail - recordLengthAligned; final int recordOffset = (int)latestRecord & (CAPACITY - 1); when(buffer.getLongVolatile(TAIL_INTENT_COUNTER_OFFSET)).thenReturn(tail); when(buffer.getLongVolatile(TAIL_COUNTER_INDEX)).thenReturn(tail); when(buffer.getLong(LATEST_COUNTER_INDEX)).thenReturn(latestRecord); when(buffer.getInt(lengthOffset(recordOffset))).thenReturn(recordLength); when(buffer.getInt(typeOffset(recordOffset))).thenReturn(MSG_TYPE_ID); assertTrue(broadcastReceiver.receiveNext()); assertThat(broadcastReceiver.typeId(), is(MSG_TYPE_ID)); assertThat(broadcastReceiver.buffer(), is(buffer)); assertThat(broadcastReceiver.offset(), is(msgOffset(recordOffset))); assertThat(broadcastReceiver.length(), is(length)); assertTrue(broadcastReceiver.validate()); assertThat(broadcastReceiver.lappedCount(), is(greaterThan(0L))); }
private void captureEntriesFromBuffer( final ByteBuffer byteBuffer, final UnsafeBuffer buffer, final ArrayList<Entry> entries) { for (int i = 0, length = byteBuffer.limit(); i < length; i += ENTRY_LENGTH) { final int entryType = buffer.getInt(i + ENTRY_TYPE_OFFSET); if (NULL_VALUE != entryType) { final Entry entry = new Entry( buffer.getLong(i + RECORDING_ID_OFFSET, LITTLE_ENDIAN), buffer.getLong(i + LEADERSHIP_TERM_ID_OFFSET, LITTLE_ENDIAN), buffer.getLong(i + TERM_BASE_LOG_POSITION_OFFSET, LITTLE_ENDIAN), buffer.getLong(i + LOG_POSITION_OFFSET, LITTLE_ENDIAN), buffer.getLong(i + TIMESTAMP_OFFSET, LITTLE_ENDIAN), buffer.getInt(i + SERVICE_ID_OFFSET, LITTLE_ENDIAN), entryType, nextEntryIndex); entries.add(entry); if (ENTRY_TYPE_TERM == entryType) { indexByLeadershipTermIdMap.put(entry.leadershipTermId, nextEntryIndex); } } ++nextEntryIndex; } }
/** * Insert a packet of frames into the log at the appropriate termOffset as indicated by the term termOffset header. * <p> * If the packet has already been inserted then this is a noop. * * @param termBuffer into which the packet should be inserted. * @param termOffset in the term at which the packet should be inserted. * @param packet containing a sequence of frames. * @param length of the packet of frames in bytes. */ public static void insert( final UnsafeBuffer termBuffer, final int termOffset, final UnsafeBuffer packet, final int length) { if (0 == termBuffer.getInt(termOffset)) { termBuffer.putBytes(termOffset + HEADER_LENGTH, packet, HEADER_LENGTH, length - HEADER_LENGTH); termBuffer.putLong(termOffset + 24, packet.getLong(24)); termBuffer.putLong(termOffset + 16, packet.getLong(16)); termBuffer.putLong(termOffset + 8, packet.getLong(8)); termBuffer.putLongOrdered(termOffset, packet.getLong(0)); } } }
@Test public void shouldInsertIntoEmptyBuffer() { final UnsafeBuffer packet = new UnsafeBuffer(ByteBuffer.allocateDirect(256)); final int termOffset = 0; final int srcOffset = 0; final int length = 256; packet.putInt(srcOffset, length, LITTLE_ENDIAN); TermRebuilder.insert(termBuffer, termOffset, packet, length); final InOrder inOrder = inOrder(termBuffer); inOrder.verify(termBuffer).putBytes( termOffset + HEADER_LENGTH, packet, srcOffset + HEADER_LENGTH, length - HEADER_LENGTH); inOrder.verify(termBuffer).putLong(termOffset + 24, packet.getLong(24)); inOrder.verify(termBuffer).putLong(termOffset + 16, packet.getLong(16)); inOrder.verify(termBuffer).putLong(termOffset + 8, packet.getLong(8)); inOrder.verify(termBuffer).putLongOrdered(termOffset, packet.getLong(0)); }
@Test public void shouldUpdateEntry() { final long initialBytesLost = 32; final int timestampMs = 7; final int sessionId = 3; final int streamId = 1; final String channel = "aeron:udp://stuff"; final String source = "127.0.0.1:8888"; final ReportEntry entry = lossReport.createEntry(initialBytesLost, timestampMs, sessionId, streamId, channel, source); final long additionBytesLost = 64; final long latestTimestamp = 10; entry.recordObservation(additionBytesLost, latestTimestamp); assertThat(unsafeBuffer.getLong(LAST_OBSERVATION_OFFSET), is(latestTimestamp)); assertThat(unsafeBuffer.getLong(TOTAL_BYTES_LOST_OFFSET), is(initialBytesLost + additionBytesLost)); assertThat(unsafeBuffer.getLong(OBSERVATION_COUNT_OFFSET), is(2L)); } }
@Test public void shouldReadNothingFromEmptyBuffer() { final long head = 0L; when(buffer.getLong(HEAD_COUNTER_INDEX)).thenReturn(head); final MessageHandler handler = (msgTypeId, buffer, index, length) -> fail("should not be called"); final int messagesRead = ringBuffer.read(handler); assertThat(messagesRead, is(0)); }
@Test public void shouldReadNothingFromEmptyBuffer() { final long head = 0L; when(buffer.getLong(HEAD_COUNTER_INDEX)).thenReturn(head); final MessageHandler handler = (msgTypeId, buffer, index, length) -> fail("should not be called"); final int messagesRead = ringBuffer.read(handler); assertThat(messagesRead, is(0)); }
@Test public void shouldNotReadSingleMessagePartWayThroughWriting() { final long head = 0L; final int headIndex = (int)head; when(buffer.getLong(HEAD_COUNTER_INDEX)).thenReturn(head); when(buffer.getIntVolatile(lengthOffset(headIndex))).thenReturn(0); final int[] times = new int[1]; final MessageHandler handler = (msgTypeId, buffer, index, length) -> times[0]++; final int messagesRead = ringBuffer.read(handler); assertThat(messagesRead, is(0)); assertThat(times[0], is(0)); final InOrder inOrder = inOrder(buffer); inOrder.verify(buffer, times(1)).getIntVolatile(lengthOffset(headIndex)); inOrder.verify(buffer, times(0)).setMemory(headIndex, 0, (byte)0); inOrder.verify(buffer, times(0)).putLongOrdered(HEAD_COUNTER_INDEX, headIndex); }
@Test public void shouldNotReadSingleMessagePartWayThroughWriting() { final long head = 0L; final int headIndex = (int)head; when(buffer.getLong(HEAD_COUNTER_INDEX)).thenReturn(head); when(buffer.getIntVolatile(lengthOffset(headIndex))).thenReturn(0); final int[] times = new int[1]; final MessageHandler handler = (msgTypeId, buffer, index, length) -> times[0]++; final int messagesRead = ringBuffer.read(handler); assertThat(messagesRead, is(0)); assertThat(times[0], is(0)); final InOrder inOrder = inOrder(buffer); inOrder.verify(buffer, times(1)).getIntVolatile(lengthOffset(headIndex)); inOrder.verify(buffer, times(0)).setMemory(anyInt(), anyInt(), anyByte()); inOrder.verify(buffer, times(0)).putLongOrdered(HEAD_COUNTER_INDEX, headIndex); }
public RecordingSummary recordingSummary(final long recordingId, final RecordingSummary summary) { final int offset = recordingDescriptorOffset(recordingId) + RecordingDescriptorHeaderDecoder.BLOCK_LENGTH; summary.recordingId = recordingId; summary.startPosition = fieldAccessBuffer.getLong(offset + startPositionEncodingOffset(), BYTE_ORDER); summary.stopPosition = fieldAccessBuffer.getLong(offset + stopPositionEncodingOffset(), BYTE_ORDER); summary.initialTermId = fieldAccessBuffer.getInt(offset + initialTermIdEncodingOffset(), BYTE_ORDER); summary.segmentFileLength = fieldAccessBuffer.getInt(offset + segmentFileLengthEncodingOffset(), BYTE_ORDER); summary.termBufferLength = fieldAccessBuffer.getInt(offset + termBufferLengthEncodingOffset(), BYTE_ORDER); summary.mtuLength = fieldAccessBuffer.getInt(offset + mtuLengthEncodingOffset(), BYTE_ORDER); summary.streamId = fieldAccessBuffer.getInt(offset + streamIdEncodingOffset(), BYTE_ORDER); summary.sessionId = fieldAccessBuffer.getInt(offset + sessionIdEncodingOffset(), BYTE_ORDER); return summary; }
@Test public void sharedBuffer() { final ByteBuffer bb = ByteBuffer.allocateDirect(1024); final UnsafeBuffer ub1 = new UnsafeBuffer(bb, 0, 512); final UnsafeBuffer ub2 = new UnsafeBuffer(bb, 512, 512); ub1.putLong(INDEX, LONG_VALUE); ub2.putLong(INDEX, 9876543210L); assertThat(ub1.getLong(INDEX), is(LONG_VALUE)); }
@Test public void shouldTransmitIntoEmptyBuffer() { final long tail = 0L; final int recordOffset = (int)tail; final int length = 8; final int recordLength = length + HEADER_LENGTH; final int recordLengthAligned = align(recordLength, RECORD_ALIGNMENT); final UnsafeBuffer srcBuffer = new UnsafeBuffer(new byte[1024]); final int srcIndex = 0; broadcastTransmitter.transmit(MSG_TYPE_ID, srcBuffer, srcIndex, length); final InOrder inOrder = inOrder(buffer); inOrder.verify(buffer).getLong(TAIL_COUNTER_INDEX); inOrder.verify(buffer).putLongOrdered(TAIL_INTENT_COUNTER_OFFSET, tail + recordLengthAligned); inOrder.verify(buffer).putInt(lengthOffset(recordOffset), recordLength); inOrder.verify(buffer).putInt(typeOffset(recordOffset), MSG_TYPE_ID); inOrder.verify(buffer).putBytes(msgOffset(recordOffset), srcBuffer, srcIndex, length); inOrder.verify(buffer).putLong(LATEST_COUNTER_INDEX, tail); inOrder.verify(buffer).putLongOrdered(TAIL_COUNTER_INDEX, tail + recordLengthAligned); }
static void validateFrame(final UnsafeBuffer buffer, final int message, final byte flags) { final int offset = message * FRAME_LENGTH; assertEquals(FRAME_LENGTH, FrameDescriptor.frameLength(buffer, offset)); assertEquals(flags, FrameDescriptor.frameFlags(buffer, offset)); assertEquals(message, buffer.getLong(offset + DataHeaderFlyweight.RESERVED_VALUE_OFFSET)); assertEquals(message, buffer.getByte(offset + DataHeaderFlyweight.HEADER_LENGTH)); } }