public void ShouldAppendUnfragmentedFromVectorsToEmptyLog()
{
var headerLength = _defaultHeader.Capacity;
var bufferOne = new UnsafeBuffer(new byte[64]);
var bufferTwo = new UnsafeBuffer(new byte[256]);
bufferOne.SetMemory(0, bufferOne.Capacity, (byte)'1');
bufferTwo.SetMemory(0, bufferTwo.Capacity, (byte)'2');
var msgLength = bufferOne.Capacity + 200;
var framgeLength = msgLength + headerLength;
var alignedFrameLength = BitUtil.Align(framgeLength, FrameDescriptor.FRAME_ALIGNMENT);
var tail = 0;
_logMetaDataBuffer.PutLong(TermTailCounterOffset, LogBufferDescriptor.PackTail(TermID, tail));
var vectors = new[]
{
new DirectBufferVector(bufferOne, 0, bufferOne.Capacity),
new DirectBufferVector(bufferTwo, 0, 200)
};
Assert.AreEqual(alignedFrameLength, _termAppender.AppendUnfragmentedMessage(_headerWriter, vectors, msgLength, RVS, TermID));
Assert.AreEqual(LogBufferDescriptor.PackTail(TermID, tail + alignedFrameLength), LogBufferDescriptor.RawTailVolatile(_logMetaDataBuffer, PartionIndex));
A.CallTo(() => _headerWriter.Write(_termBuffer, tail, framgeLength, TermID)).MustHaveHappened()
.Then(A.CallTo(() => _termBuffer.PutBytes(headerLength, bufferOne, 0, bufferOne.Capacity)).MustHaveHappened())
.Then(A.CallTo(() => _termBuffer.PutBytes(headerLength + bufferOne.Capacity, bufferTwo, 0, 200)).MustHaveHappened())
.Then(A.CallTo(() => _termBuffer.PutLong(tail + DataHeaderFlyweight.RESERVED_VALUE_OFFSET, RV, ByteOrder.LittleEndian)).MustHaveHappened())
.Then(A.CallTo(() => _termBuffer.PutIntOrdered(tail, framgeLength)).MustHaveHappened());
}
public ClusterMarkFile(
FileInfo file,
ClusterComponentType type,
int errorBufferLength,
IEpochClock epochClock,
long timeoutMs)
{
var markFileExists = file.Exists;
markFile = new MarkFile(
file,
markFileExists,
MarkFileHeaderDecoder.VersionEncodingOffset(),
MarkFileHeaderDecoder.ActivityTimestampEncodingOffset(),
HEADER_LENGTH + errorBufferLength,
timeoutMs,
epochClock,
(version) =>
{
if (version != MarkFileHeaderDecoder.SCHEMA_VERSION)
{
throw new ClusterException("mark file version " + version + " does not match software:" + MarkFileHeaderDecoder.SCHEMA_VERSION);
}
},
null);
buffer = markFile.Buffer();
errorBuffer = new UnsafeBuffer(buffer, HEADER_LENGTH, errorBufferLength);
headerEncoder.Wrap(buffer, 0);
headerDecoder.Wrap(buffer, 0, MarkFileHeaderDecoder.BLOCK_LENGTH, MarkFileHeaderDecoder.SCHEMA_VERSION);
if (markFileExists)
{
var existingErrorBuffer = new UnsafeBuffer(
buffer, headerDecoder.HeaderLength(), headerDecoder.ErrorBufferLength());
SaveExistingErrors(file, existingErrorBuffer, Console.Error);
errorBuffer.SetMemory(0, errorBufferLength, 0);
}
else
{
headerEncoder.CandidateTermId(Aeron.Aeron.NULL_VALUE);
}
var existingType = headerDecoder.ComponentType();
if (existingType != ClusterComponentType.NULL && existingType != type)
{
throw new InvalidOperationException("existing Mark file type " + existingType + " not same as required type " + type);
}
headerEncoder.ComponentType(type);
headerEncoder.HeaderLength(HEADER_LENGTH);
headerEncoder.ErrorBufferLength(errorBufferLength);
headerEncoder.Pid(Process.GetCurrentProcess().Id);
headerEncoder.StartTimestamp(epochClock.Time());
}
public void ShouldAppendUnfragmentedFromVectorsToEmptyLog()
{
var headerLength = _defaultHeader.Capacity;
var bufferOne = new UnsafeBuffer(new byte[64]);
var bufferTwo = new UnsafeBuffer(new byte[256]);
bufferOne.SetMemory(0, bufferOne.Capacity, (byte)'1');
bufferTwo.SetMemory(0, bufferTwo.Capacity, (byte)'2');
var msgLength = bufferOne.Capacity + 200;
var framgeLength = msgLength + headerLength;
var alignedFrameLength = BitUtil.Align(framgeLength, FrameDescriptor.FRAME_ALIGNMENT);
var tail = 0;
_logMetaDataBuffer.PutLong(TermTailCounterOffset, LogBufferDescriptor.PackTail(TermID, tail));
var vectors = new[]
{
new DirectBufferVector(bufferOne, 0, bufferOne.Capacity),
new DirectBufferVector(bufferTwo, 0, 200)
};
Assert.That(_termAppender.AppendUnfragmentedMessage(_headerWriter, vectors, msgLength, RVS, TermID), Is.EqualTo(alignedFrameLength));
Assert.AreEqual(LogBufferDescriptor.RawTailVolatile(_logMetaDataBuffer, PartionIndex), LogBufferDescriptor.PackTail(TermID, tail + alignedFrameLength));
}
public void ShouldFreeSessionBuffer()
{
A.CallTo(() => header.Flags).ReturnsNextFromSequence(FrameDescriptor.BEGIN_FRAG_FLAG, FrameDescriptor.END_FRAG_FLAG);
var srcBuffer = new UnsafeBuffer(new byte[1024]);
const int offset = 0;
var length = srcBuffer.Capacity / 2;
srcBuffer.SetMemory(0, length, 65);
srcBuffer.SetMemory(length, length, 66);
Assert.False(adapter.FreeSessionBuffer(SESSION_ID));
adapter.OnFragment(srcBuffer, offset, length, header);
adapter.OnFragment(srcBuffer, length, length, header);
Assert.True(adapter.FreeSessionBuffer(SESSION_ID));
Assert.False(adapter.FreeSessionBuffer(SESSION_ID));
}
public void ShouldAssembleTwoPartMessage()
{
A.CallTo(() => header.Flags).ReturnsNextFromSequence(FrameDescriptor.BEGIN_FRAG_FLAG, FrameDescriptor.END_FRAG_FLAG, FrameDescriptor.END_FRAG_FLAG);
// Need to add this twice because FakeItEasy doesn't fall back to the implementation
var srcBuffer = new UnsafeBuffer(new byte[1024]);
const int offset = 0;
var length = srcBuffer.Capacity / 2;
srcBuffer.SetMemory(0, length, 65);
srcBuffer.SetMemory(length, length, 66);
adapter.OnFragment(srcBuffer, offset, length, header);
adapter.OnFragment(srcBuffer, length, length, header);
Func <UnsafeBuffer, bool> bufferAssertion = capturedBuffer =>
{
for (var i = 0; i < srcBuffer.Capacity; i++)
{
if (capturedBuffer.GetByte(i) != srcBuffer.GetByte(i))
{
return(false);
}
}
return(true);
};
Func <Header, bool> headerAssertion = capturedHeader => capturedHeader.SessionId == SESSION_ID &&
capturedHeader.Flags == FrameDescriptor.END_FRAG_FLAG;
A.CallTo(() => delegateFragmentHandler(
A <UnsafeBuffer> .That.Matches(bufferAssertion, "buffer"),
offset,
length * 2,
A <Header> .That.Matches(headerAssertion, "header")))
.MustHaveHappened(Repeated.Exactly.Once);
}
public void ShouldAppendFragmentedFromVectorsWithNonZeroOffsetToEmptyLog()
{
var mtu = 2048;
var headerLength = _defaultHeader.Capacity;
var maxPayloadLength = mtu - headerLength;
var bufferOneLength = 64;
var offset = 15;
var bufferTwoTotalLength = 3000;
var bufferTwoLength = bufferTwoTotalLength - offset;
var bufferOne = new UnsafeBuffer(new byte[bufferOneLength]);
var bufferTwo = new UnsafeBuffer(new byte[bufferTwoTotalLength]);
bufferOne.SetMemory(0, bufferOne.Capacity, (byte)'1');
bufferTwo.SetMemory(0, bufferTwo.Capacity, (byte)'2');
var msgLength = bufferOneLength + bufferTwoLength;
var tail = 0;
var frameOneLength = mtu;
var frameTwoLength = (msgLength - (mtu - headerLength)) + headerLength;
var resultingOffset = frameOneLength + BitUtil.Align(frameTwoLength, FrameDescriptor.FRAME_ALIGNMENT);
_logMetaDataBuffer.PutLong(TermTailCounterOffset, LogBufferDescriptor.PackTail(TermID, tail));
var vectors = new[]
{
new DirectBufferVector(bufferOne, 0, bufferOneLength),
new DirectBufferVector(bufferTwo, offset, bufferTwoLength)
};
Assert.That(_termAppender.AppendFragmentedMessage(_headerWriter, vectors, msgLength, maxPayloadLength, RVS, TermID), Is.EqualTo(resultingOffset));
var tail2 = tail + frameOneLength;
var bufferTwoOffset = maxPayloadLength - bufferOneLength + offset;
var fragmentTwoPayloadLength = bufferTwoLength - (maxPayloadLength - bufferOneLength);
A.CallTo(() => _headerWriter.Write(_termBuffer, tail, frameOneLength, TermID)).MustHaveHappened()
.Then(A.CallTo(() => _termBuffer.PutBytes(headerLength, bufferOne, 0, bufferOneLength)).MustHaveHappened())
.Then(A.CallTo(() => _termBuffer.PutBytes(headerLength + bufferOneLength, bufferTwo, offset, maxPayloadLength - bufferOneLength)).MustHaveHappened())
.Then(A.CallTo(() => _termBuffer.PutLong(tail + DataHeaderFlyweight.RESERVED_VALUE_OFFSET, RV, ByteOrder.LittleEndian)).MustHaveHappened())
.Then(A.CallTo(() => _termBuffer.PutIntOrdered(tail, frameOneLength)).MustHaveHappened())
.Then(A.CallTo(() => _headerWriter.Write(_termBuffer, tail2, frameTwoLength, TermID)).MustHaveHappened())
.Then(A.CallTo(() => _termBuffer.PutBytes(tail2 + headerLength, bufferTwo, bufferTwoOffset, fragmentTwoPayloadLength)).MustHaveHappened())
.Then(A.CallTo(() => _termBuffer.PutLong(tail2 + DataHeaderFlyweight.RESERVED_VALUE_OFFSET, RV, ByteOrder.LittleEndian)).MustHaveHappened())
.Then(A.CallTo(() => _termBuffer.PutIntOrdered(tail2, frameTwoLength)).MustHaveHappened());
}
public void ShouldAssembleFourPartMessage()
{
A.CallTo(() => header.Flags).ReturnsNextFromSequence <byte>(FrameDescriptor.BEGIN_FRAG_FLAG, 0, 0, FrameDescriptor.END_FRAG_FLAG, FrameDescriptor.END_FRAG_FLAG);
var srcBuffer = new UnsafeBuffer(new byte[1024]);
const int offset = 0;
var length = srcBuffer.Capacity / 4;
for (var i = 0; i < 4; i++)
{
srcBuffer.SetMemory(i * length, length, (byte)(65 + i));
}
adapter.OnFragment(srcBuffer, offset, length, header);
adapter.OnFragment(srcBuffer, offset + length, length, header);
adapter.OnFragment(srcBuffer, offset + (length * 2), length, header);
adapter.OnFragment(srcBuffer, offset + (length * 3), length, header);
Func <UnsafeBuffer, bool> bufferAssertion = capturedBuffer =>
{
for (var i = 0; i < srcBuffer.Capacity; i++)
{
if (capturedBuffer.GetByte(i) != srcBuffer.GetByte(i))
{
return(false);
}
}
return(true);
};
Func <Header, bool> headerAssertion = capturedHeader => capturedHeader.SessionId == SESSION_ID &&
capturedHeader.Flags == FrameDescriptor.END_FRAG_FLAG;
A.CallTo(() => delegateFragmentHandler(
A <UnsafeBuffer> .That.Matches(bufferAssertion, "buffer"),
offset,
length * 4,
A <Header> .That.Matches(headerAssertion, "header")))
.MustHaveHappened(Repeated.Exactly.Once);
}
public ClusterMarkFile(
FileInfo file,
ClusterComponentType type,
int errorBufferLength,
IEpochClock epochClock,
long timeoutMs)
{
var markFileExists = file.Exists;
markFile = new MarkFile(
file,
markFileExists,
MarkFileHeaderDecoder.VersionEncodingOffset(),
MarkFileHeaderDecoder.ActivityTimestampEncodingOffset(),
HEADER_LENGTH + errorBufferLength,
timeoutMs,
epochClock,
(version) =>
{
if (VERSION_FAILED == version && markFileExists)
{
Console.WriteLine("mark file version -1 indicates error on previous startup.");
}
else if (SemanticVersion.Major(version) != AeronCluster.Configuration.MAJOR_VERSION)
{
throw new ArgumentException("mark file major version " + SemanticVersion.Major(version) +
" does not match software:" + AeronCluster.Configuration.MAJOR_VERSION);
}
},
null);
buffer = markFile.Buffer();
errorBuffer = new UnsafeBuffer(buffer, HEADER_LENGTH, errorBufferLength);
headerEncoder.Wrap(buffer, 0);
headerDecoder.Wrap(buffer, 0, MarkFileHeaderDecoder.BLOCK_LENGTH, MarkFileHeaderDecoder.SCHEMA_VERSION);
if (markFileExists)
{
var existingErrorBuffer = new UnsafeBuffer(
buffer, headerDecoder.HeaderLength(), headerDecoder.ErrorBufferLength());
SaveExistingErrors(file, existingErrorBuffer, Console.Error);
errorBuffer.SetMemory(0, errorBufferLength, 0);
}
else
{
headerEncoder.CandidateTermId(Aeron.Aeron.NULL_VALUE);
}
var existingType = headerDecoder.ComponentType();
if (existingType != ClusterComponentType.NULL && existingType != type)
{
if (existingType != ClusterComponentType.BACKUP || ClusterComponentType.CONSENSUS_MODULE != type)
{
throw new InvalidOperationException(
"existing Mark file type " + existingType + " not same as required type " + type);
}
}
headerEncoder.ComponentType(type);
headerEncoder.HeaderLength(HEADER_LENGTH);
headerEncoder.ErrorBufferLength(errorBufferLength);
headerEncoder.Pid(Process.GetCurrentProcess().Id);
headerEncoder.StartTimestamp(epochClock.Time());
}
/// <summary>
/// Clean down the buffers for reuse by zeroing them out.
/// </summary>
public void Clean()
{
_termBuffer.SetMemory(0, _termBuffer.Capacity, 0);
_metaDataBuffer.PutInt(LogBufferDescriptor.TERM_STATUS_OFFSET, LogBufferDescriptor.CLEAN);
}
