static boolean isInvalidHeader( final UnsafeBuffer buffer, final int streamId, final int termId, final int termOffset) { return DataHeaderFlyweight.termOffset(buffer, 0) != termOffset || DataHeaderFlyweight.termId(buffer, 0) != termId || DataHeaderFlyweight.streamId(buffer, 0) != streamId; } }
public String toString() { final StringBuilder sb = new StringBuilder(); final String formattedFlags = String.format("%1$8s", Integer.toBinaryString(flags())).replace(' ', '0'); sb.append("DATA Header{") .append("frame_length=").append(frameLength()) .append(" version=").append(version()) .append(" flags=").append(formattedFlags) .append(" type=").append(headerType()) .append(" term_offset=").append(termOffset()) .append(" session_id=").append(sessionId()) .append(" stream_id=").append(streamId()) .append(" term_id=").append(termId()) .append(" reserved_value=").append(reservedValue()) .append("}"); return sb.toString(); } }
private static void dissect(final DataHeaderFlyweight msg, final StringBuilder builder) { builder .append(msg.headerType() == HeaderFlyweight.HDR_TYPE_PAD ? "PAD" : "DATA") .append(' ') .append(msg.flags()) .append(" len ") .append(msg.frameLength()) .append(' ') .append(msg.sessionId()) .append(':') .append(msg.streamId()) .append(':') .append(msg.termId()) .append(" @") .append(msg.termOffset()); }
@Before public void setUp() { when(mockHeader.sessionId()).thenReturn(SESSION_ID); when(mockHeader.streamId()).thenReturn(STREAM_ID); when(mockHeader.termId()).thenReturn(ACTIVE_TERM_ID); when(mockHeader.termOffset()).thenReturn(TERM_OFFSET); when(mockImage.sessionId()).thenReturn(SESSION_ID); when(mockImage.streamId()).thenReturn(STREAM_ID); when(mockSetupHeader.sessionId()).thenReturn(SESSION_ID); when(mockSetupHeader.streamId()).thenReturn(STREAM_ID); when(mockSetupHeader.activeTermId()).thenReturn(ACTIVE_TERM_ID); when(mockSetupHeader.initialTermId()).thenReturn(INITIAL_TERM_ID); when(mockSetupHeader.termOffset()).thenReturn(TERM_OFFSET); when(mockSetupHeader.mtuLength()).thenReturn(MTU_LENGTH); when(mockSetupHeader.termLength()).thenReturn(TERM_LENGTH); }
private int heartbeatMessageCheck( final long nowNs, final int activeTermId, final int termOffset, final boolean isEndOfStream) { int bytesSent = 0; if ((timeOfLastSendOrHeartbeatNs + PUBLICATION_HEARTBEAT_TIMEOUT_NS) - nowNs < 0) { heartbeatBuffer.clear(); heartbeatDataHeader .sessionId(sessionId) .streamId(streamId) .termId(activeTermId) .termOffset(termOffset) .flags((byte)(isEndOfStream ? BEGIN_END_AND_EOS_FLAGS : BEGIN_AND_END_FLAGS)); bytesSent = channelEndpoint.send(heartbeatBuffer); if (DataHeaderFlyweight.HEADER_LENGTH != bytesSent) { shortSends.increment(); } timeOfLastSendOrHeartbeatNs = nowNs; heartbeatsSent.incrementOrdered(); } return bytesSent; }
@Test public void shouldNotSendUntilStatusMessageReceived() { final UnsafeBuffer buffer = new UnsafeBuffer(ByteBuffer.allocateDirect(PAYLOAD.length)); buffer.putBytes(0, PAYLOAD); termAppenders[0].appendUnfragmentedMessage(headerWriter, buffer, 0, PAYLOAD.length, null, INITIAL_TERM_ID); sender.doWork(); assertThat(receivedFrames.size(), is(1)); setupHeader.wrap(receivedFrames.remove()); assertThat(setupHeader.headerType(), is(HeaderFlyweight.HDR_TYPE_SETUP)); final StatusMessageFlyweight msg = mock(StatusMessageFlyweight.class); when(msg.consumptionTermId()).thenReturn(INITIAL_TERM_ID); when(msg.consumptionTermOffset()).thenReturn(0); when(msg.receiverWindowLength()).thenReturn(ALIGNED_FRAME_LENGTH); publication.onStatusMessage(msg, rcvAddress); sender.doWork(); assertThat(receivedFrames.size(), is(1)); dataHeader.wrap(new UnsafeBuffer(receivedFrames.remove())); assertThat(dataHeader.frameLength(), is(FRAME_LENGTH)); assertThat(dataHeader.termId(), is(INITIAL_TERM_ID)); assertThat(dataHeader.streamId(), is(STREAM_ID)); assertThat(dataHeader.sessionId(), is(SESSION_ID)); assertThat(dataHeader.termOffset(), is(offsetOfMessage(1))); assertThat(dataHeader.headerType(), is(HeaderFlyweight.HDR_TYPE_DATA)); assertThat(dataHeader.flags(), is(DataHeaderFlyweight.BEGIN_AND_END_FLAGS)); assertThat(dataHeader.version(), is((short)HeaderFlyweight.CURRENT_VERSION)); }
@Test public void shouldNotBeAbleToSendAfterUsingUpYourWindow() { final UnsafeBuffer buffer = new UnsafeBuffer(ByteBuffer.allocateDirect(PAYLOAD.length)); buffer.putBytes(0, PAYLOAD); termAppenders[0].appendUnfragmentedMessage(headerWriter, buffer, 0, PAYLOAD.length, null, INITIAL_TERM_ID); final StatusMessageFlyweight msg = mock(StatusMessageFlyweight.class); when(msg.consumptionTermId()).thenReturn(INITIAL_TERM_ID); when(msg.consumptionTermOffset()).thenReturn(0); when(msg.receiverWindowLength()).thenReturn(ALIGNED_FRAME_LENGTH); publication.onStatusMessage(msg, rcvAddress); sender.doWork(); assertThat(receivedFrames.size(), is(2)); receivedFrames.remove(); // skip setup dataHeader.wrap(new UnsafeBuffer(receivedFrames.remove())); assertThat(dataHeader.frameLength(), is(FRAME_LENGTH)); assertThat(dataHeader.termId(), is(INITIAL_TERM_ID)); assertThat(dataHeader.streamId(), is(STREAM_ID)); assertThat(dataHeader.sessionId(), is(SESSION_ID)); assertThat(dataHeader.termOffset(), is(offsetOfMessage(1))); assertThat(dataHeader.headerType(), is(HeaderFlyweight.HDR_TYPE_DATA)); assertThat(dataHeader.flags(), is(DataHeaderFlyweight.BEGIN_AND_END_FLAGS)); assertThat(dataHeader.version(), is((short)HeaderFlyweight.CURRENT_VERSION)); termAppenders[0].appendUnfragmentedMessage(headerWriter, buffer, 0, PAYLOAD.length, null, INITIAL_TERM_ID); sender.doWork(); assertThat(receivedFrames.size(), is(0)); }
@Test public void shouldBeAbleToSendOnChannel() { final StatusMessageFlyweight msg = mock(StatusMessageFlyweight.class); when(msg.consumptionTermId()).thenReturn(INITIAL_TERM_ID); when(msg.consumptionTermOffset()).thenReturn(0); when(msg.receiverWindowLength()).thenReturn(ALIGNED_FRAME_LENGTH); publication.onStatusMessage(msg, rcvAddress); final UnsafeBuffer buffer = new UnsafeBuffer(ByteBuffer.allocateDirect(PAYLOAD.length)); buffer.putBytes(0, PAYLOAD); termAppenders[0].appendUnfragmentedMessage(headerWriter, buffer, 0, PAYLOAD.length, null, INITIAL_TERM_ID); sender.doWork(); assertThat(receivedFrames.size(), is(2)); setupHeader.wrap(new UnsafeBuffer(receivedFrames.remove())); assertThat(setupHeader.headerType(), is(HeaderFlyweight.HDR_TYPE_SETUP)); dataHeader.wrap(new UnsafeBuffer(receivedFrames.remove())); assertThat(dataHeader.frameLength(), is(FRAME_LENGTH)); assertThat(dataHeader.termId(), is(INITIAL_TERM_ID)); assertThat(dataHeader.streamId(), is(STREAM_ID)); assertThat(dataHeader.sessionId(), is(SESSION_ID)); assertThat(dataHeader.termOffset(), is(offsetOfMessage(1))); assertThat(dataHeader.headerType(), is(HeaderFlyweight.HDR_TYPE_DATA)); assertThat(dataHeader.flags(), is(DataHeaderFlyweight.BEGIN_AND_END_FLAGS)); assertThat(dataHeader.version(), is((short)HeaderFlyweight.CURRENT_VERSION)); }
@Test public void shouldReadAndWriteDataHeaderCorrectly() { encodeDataHeader.wrap(aBuff); encodeDataHeader.version((short)1); encodeDataHeader.flags(DataHeaderFlyweight.BEGIN_AND_END_FLAGS); encodeDataHeader.headerType(HeaderFlyweight.HDR_TYPE_DATA); encodeDataHeader.frameLength(DataHeaderFlyweight.HEADER_LENGTH); encodeDataHeader.sessionId(0xdeadbeef); encodeDataHeader.streamId(0x44332211); encodeDataHeader.termId(0x99887766); decodeDataHeader.wrap(aBuff); assertThat(decodeDataHeader.version(), is((short)1)); assertThat(decodeDataHeader.flags(), is(DataHeaderFlyweight.BEGIN_AND_END_FLAGS)); assertThat(decodeDataHeader.headerType(), is(HeaderFlyweight.HDR_TYPE_DATA)); assertThat(decodeDataHeader.frameLength(), is(DataHeaderFlyweight.HEADER_LENGTH)); assertThat(decodeDataHeader.sessionId(), is(0xdeadbeef)); assertThat(decodeDataHeader.streamId(), is(0x44332211)); assertThat(decodeDataHeader.termId(), is(0x99887766)); assertThat(decodeDataHeader.dataOffset(), is(DataHeaderFlyweight.HEADER_LENGTH)); }
private void initPublicationMetadata( final int sessionId, final int streamId, final int initialTermId, final long registrationId, final PublicationParams params, final RawLog rawLog) { final UnsafeBuffer logMetaData = rawLog.metaData(); defaultDataHeader.sessionId(sessionId).streamId(streamId).termId(initialTermId); storeDefaultFrameHeader(logMetaData, defaultDataHeader); initialTermId(logMetaData, initialTermId); mtuLength(logMetaData, params.mtuLength); termLength(logMetaData, rawLog.termLength()); pageSize(logMetaData, ctx.filePageSize()); correlationId(logMetaData, registrationId); endOfStreamPosition(logMetaData, Long.MAX_VALUE); initialisePositionCounters(initialTermId, params, logMetaData); }
@Test public void shouldFillGapAfterExistingFrame() { final int gapOffset = 128; final int gapLength = 64; dataFlyweight .sessionId(SESSION_ID) .termId(TERM_ID) .streamId(STREAM_ID) .flags(UNFRAGMENTED) .frameLength(gapOffset); dataFlyweight.setMemory(0, gapOffset - DataHeaderFlyweight.HEADER_LENGTH, (byte)'x'); assertTrue(TermGapFiller.tryFillGap(metaDataBuffer, termBuffer, TERM_ID, gapOffset, gapLength)); dataFlyweight.wrap(termBuffer, gapOffset, termBuffer.capacity() - gapOffset); assertThat(dataFlyweight.frameLength(), is(gapLength)); assertThat(dataFlyweight.termOffset(), is(gapOffset)); assertThat(dataFlyweight.sessionId(), is(SESSION_ID)); assertThat(dataFlyweight.termId(), is(TERM_ID)); assertThat(dataFlyweight.headerType(), is(PADDING_FRAME_TYPE)); assertThat((byte)(dataFlyweight.flags()), is(UNFRAGMENTED)); }
private RawLog newPublicationImageLog( final int sessionId, final int streamId, final int initialTermId, final int termBufferLength, final boolean isSparse, final int senderMtuLength, final UdpChannel udpChannel, final long correlationId) { final RawLog rawLog = rawLogFactory.newNetworkedImage( udpChannel.canonicalForm(), sessionId, streamId, correlationId, termBufferLength, isSparse); final UnsafeBuffer logMetaData = rawLog.metaData(); defaultDataHeader.sessionId(sessionId).streamId(streamId).termId(initialTermId); storeDefaultFrameHeader(logMetaData, defaultDataHeader); initialTermId(logMetaData, initialTermId); mtuLength(logMetaData, senderMtuLength); termLength(logMetaData, termBufferLength); pageSize(logMetaData, ctx.filePageSize()); correlationId(logMetaData, correlationId); endOfStreamPosition(logMetaData, Long.MAX_VALUE); return rawLog; }
private void insertPaddingFrame(final int activeTermId, final int termOffset) { dataHeader .termId(INITIAL_TERM_ID) .streamId(STREAM_ID) .sessionId(SESSION_ID) .frameLength(TERM_BUFFER_LENGTH - termOffset) .headerType(HeaderFlyweight.HDR_TYPE_PAD) .flags(DataHeaderFlyweight.BEGIN_AND_END_FLAGS) .version(HeaderFlyweight.CURRENT_VERSION); final int activeIndex = indexByTerm(INITIAL_TERM_ID, activeTermId); TermRebuilder.insert(termBuffers[activeIndex], termOffset, rcvBuffer, TERM_BUFFER_LENGTH - termOffset); }
final int transportIndex) final int streamId = header.streamId(); final StreamInterest streamInterest = streamInterestByIdMap.get(streamId);
@Test public void shouldFillGapAtEndOfTerm() { final int gapOffset = termBuffer.capacity() - 64; final int gapLength = 64; dataFlyweight .sessionId(SESSION_ID) .termId(TERM_ID) .streamId(STREAM_ID) .flags(UNFRAGMENTED) .frameLength(termBuffer.capacity() - gapOffset); dataFlyweight.setMemory(0, gapOffset - DataHeaderFlyweight.HEADER_LENGTH, (byte)'x'); assertTrue(TermGapFiller.tryFillGap(metaDataBuffer, termBuffer, TERM_ID, gapOffset, gapLength)); dataFlyweight.wrap(termBuffer, gapOffset, termBuffer.capacity() - gapOffset); assertThat(dataFlyweight.frameLength(), is(gapLength)); assertThat(dataFlyweight.termOffset(), is(gapOffset)); assertThat(dataFlyweight.sessionId(), is(SESSION_ID)); assertThat(dataFlyweight.termId(), is(TERM_ID)); assertThat(dataFlyweight.headerType(), is(PADDING_FRAME_TYPE)); assertThat((byte)(dataFlyweight.flags()), is(UNFRAGMENTED)); } }
private void insertDataFrame(final int offset, final byte[] payload) { dataHeader .termId(TERM_ID) .streamId(STREAM_ID) .sessionId(SESSION_ID) .termOffset(offset) .frameLength(payload.length + DataHeaderFlyweight.HEADER_LENGTH) .headerType(HeaderFlyweight.HDR_TYPE_DATA) .flags(DataHeaderFlyweight.BEGIN_AND_END_FLAGS) .version(HeaderFlyweight.CURRENT_VERSION); rcvBuffer.putBytes(dataHeader.dataOffset(), payload); TermRebuilder.insert(termBuffer, offset, rcvBuffer, payload.length + DataHeaderFlyweight.HEADER_LENGTH); }
private void insertDataFrame(final int activeTermId, final int termOffset) { dataHeader .termId(INITIAL_TERM_ID) .streamId(STREAM_ID) .sessionId(SESSION_ID) .termOffset(termOffset) .frameLength(DATA.length + HEADER_LENGTH) .headerType(HeaderFlyweight.HDR_TYPE_DATA) .flags(DataHeaderFlyweight.BEGIN_AND_END_FLAGS) .version(HeaderFlyweight.CURRENT_VERSION); rcvBuffer.putBytes(dataHeader.dataOffset(), DATA); final int activeIndex = indexByTerm(INITIAL_TERM_ID, activeTermId); TermRebuilder.insert(termBuffers[activeIndex], termOffset, rcvBuffer, ALIGNED_FRAME_LENGTH); }
private void fillDataFrame(final DataHeaderFlyweight header, final int termOffset, final byte[] payload) { header.wrap(dataBuffer); header .termOffset(termOffset) .termId(ACTIVE_TERM_ID) .streamId(STREAM_ID) .sessionId(SESSION_ID) .frameLength(DataHeaderFlyweight.HEADER_LENGTH + payload.length) .headerType(HeaderFlyweight.HDR_TYPE_DATA) .flags(DataHeaderFlyweight.BEGIN_AND_END_FLAGS) .version(HeaderFlyweight.CURRENT_VERSION); if (0 < payload.length) { dataBuffer.putBytes(header.dataOffset(), payload); } }
private void addReceivedDataFrame(final int msgNum) { dataHeader.wrap(rcvBuffer); dataHeader.termId(TERM_ID) .streamId(STREAM_ID) .sessionId(SESSION_ID) .termOffset(offsetOfFrame(msgNum)) .frameLength(MESSAGE_LENGTH) .headerType(HeaderFlyweight.HDR_TYPE_DATA) .flags(DataHeaderFlyweight.BEGIN_AND_END_FLAGS) .version(HeaderFlyweight.CURRENT_VERSION); rcvBuffer.putBytes(dataHeader.dataOffset(), DATA); TermRebuilder.insert(termBuffer, offsetOfFrame(msgNum), rcvBuffer, MESSAGE_LENGTH); } }
private void recordFragment( final RecordingWriter recordingWriter, final UnsafeBuffer buffer, final DataHeaderFlyweight headerFlyweight, final Header header, final int message, final byte flags, final int type) { final int offset = INITIAL_TERM_OFFSET + message * FRAME_LENGTH; headerFlyweight.wrap(buffer, offset, HEADER_LENGTH); headerFlyweight .streamId(STREAM_ID) .sessionId(SESSION_ID) .termOffset(offset) .termId(INITIAL_TERM_ID) .reservedValue(message) .headerType(type) .flags(flags) .frameLength(FRAME_LENGTH); buffer.setMemory( offset + HEADER_LENGTH, FRAME_LENGTH - HEADER_LENGTH, (byte)message); header.offset(offset); recordingWriter.onBlock(buffer, offset, FRAME_LENGTH, SESSION_ID, INITIAL_TERM_ID); recordingPosition += FRAME_LENGTH; }