public virtual void SetUp()
{
RcvBuffer = new UnsafeBuffer(new byte[ALIGNED_FRAME_LENGTH]);
DataHeader = new DataHeaderFlyweight();
MockFragmentHandler = A.Fake<FragmentHandler>();
MockControlledFragmentHandler = A.Fake<IControlledFragmentHandler>();
Position = A.Fake<IPosition>(options => options.Wrapping(new AtomicLongPosition()));
LogBuffers = A.Fake<LogBuffers>();
ErrorHandler = A.Fake<ErrorHandler>();
Subscription = A.Fake<Subscription>();
AtomicBuffers = new UnsafeBuffer[(LogBufferDescriptor.PARTITION_COUNT * 2) + 1];
TermBuffers = new UnsafeBuffer[LogBufferDescriptor.PARTITION_COUNT];
DataHeader.Wrap(RcvBuffer);
for (var i = 0; i < LogBufferDescriptor.PARTITION_COUNT; i++)
{
AtomicBuffers[i] = new UnsafeBuffer(new byte[TERM_BUFFER_LENGTH]);
TermBuffers[i] = AtomicBuffers[i];
AtomicBuffers[i + LogBufferDescriptor.PARTITION_COUNT] = new UnsafeBuffer(new byte[LogBufferDescriptor.TERM_META_DATA_LENGTH]);
}
AtomicBuffers[LogBufferDescriptor.LOG_META_DATA_SECTION_INDEX] = new UnsafeBuffer(new byte[LogBufferDescriptor.LOG_META_DATA_LENGTH]);
A.CallTo(() => LogBuffers.AtomicBuffers()).Returns(AtomicBuffers);
A.CallTo(() => LogBuffers.TermLength()).Returns(TERM_BUFFER_LENGTH);
}
public void SetUp()
{
RcvBuffer = new UnsafeBuffer(new byte[ALIGNED_FRAME_LENGTH]);
DataHeader = new DataHeaderFlyweight();
MockFragmentHandler = A.Fake <FragmentHandler>();
MockControlledFragmentHandler = A.Fake <IControlledFragmentHandler>();
Position = A.Fake <IPosition>(options => options.Wrapping(new AtomicLongPosition()));
LogBuffers = A.Fake <LogBuffers>();
ErrorHandler = A.Fake <ErrorHandler>();
Subscription = A.Fake <Subscription>();
TermBuffers = new UnsafeBuffer[LogBufferDescriptor.PARTITION_COUNT];
DataHeader.Wrap(RcvBuffer);
for (var i = 0; i < LogBufferDescriptor.PARTITION_COUNT; i++)
{
TermBuffers[i] = new UnsafeBuffer(new byte[TERM_BUFFER_LENGTH]);
}
logMetaDataBuffer = new UnsafeBuffer(new byte[LogBufferDescriptor.LOG_META_DATA_LENGTH]);
A.CallTo(() => LogBuffers.TermBuffers()).Returns(TermBuffers);
A.CallTo(() => LogBuffers.TermLength()).Returns(TERM_BUFFER_LENGTH);
A.CallTo(() => LogBuffers.MetaDataBuffer()).Returns(logMetaDataBuffer);
}
public int Poll(FragmentHandler fragmentHandler, int fragmentLimit)
#endif
{
var handler = HandlerHelper.ToFragmentHandler(fragmentHandler);
return(Poll(handler, fragmentLimit));
}
public static void Main()
{
var ctx = new Aeron.Context()
.AvailableImageHandler(SamplesUtil.PrintAvailableImage)
.UnavailableImageHandler(SamplesUtil.PrintUnavailableImage);
IIdleStrategy idleStrategy = new BusySpinIdleStrategy();
Console.WriteLine("Subscribing Ping at " + PingChannel + " on stream Id " + PingStreamID);
Console.WriteLine("Publishing Pong at " + PongChannel + " on stream Id " + PongStreamID);
var running = new AtomicBoolean(true);
Console.CancelKeyPress += (_, e) => running.Set(false);
using (var aeron = Aeron.Connect(ctx))
using (var pongPublication = aeron.AddPublication(PongChannel, PongStreamID))
using (var pingSubscription = aeron.AddSubscription(PingChannel, PingStreamID))
{
FragmentHandler dataHandler = (buffer, offset, length, header) => PingHandler(pongPublication, buffer, offset, length);
while (running.Get())
{
idleStrategy.Idle(pingSubscription.Poll(dataHandler, FrameCountLimit));
}
Console.WriteLine("Shutting down...");
}
}
public void Run()
{
while (Subscription.ImageCount == 0)
{
// wait for an image to be ready
Thread.Yield();
}
var image = Subscription.Images[0];
long failedPolls = 0;
long successfulPolls = 0;
FragmentHandler onFragment = OnFragment;
while (Running.Get())
{
var fragmentsRead = image.Poll(onFragment, MessageCountLimit);
if (0 == fragmentsRead)
{
++failedPolls;
}
else
{
++successfulPolls;
}
}
var failureRatio = failedPolls / (double)(successfulPolls + failedPolls);
Console.WriteLine($"Subscriber poll failure ratio: {failureRatio}");
}
/// <summary>
/// Poll the <seealso cref="Image"/>s under the subscription for available message fragments.
/// <para>
/// Each fragment read will be a whole message if it is under MTU length. If larger than MTU then it will come
/// as a series of fragments ordered within a session.
/// </para>
/// <para>
/// To assemble messages that span multiple fragments then use <seealso cref="FragmentAssembler"/>.
///
/// </para>
/// </summary>
/// <param name="fragmentHandler"> callback for handling each message fragment as it is read. </param>
/// <param name="fragmentLimit"> number of message fragments to limit for the poll operation across multiple <seealso cref="Image"/>s. </param>
/// <returns> the number of fragments received </returns>
public int Poll(FragmentHandler fragmentHandler, int fragmentLimit)
{
var images = _images;
var length = images.Length;
var fragmentsRead = 0;
var startingIndex = _roundRobinIndex++;
if (startingIndex >= length)
{
_roundRobinIndex = startingIndex = 0;
}
for (var i = startingIndex; i < length && fragmentsRead < fragmentLimit; i++)
{
fragmentsRead += images[i].Poll(fragmentHandler, fragmentLimit - fragmentsRead);
}
for (var i = 0; i < startingIndex && fragmentsRead < fragmentLimit; i++)
{
fragmentsRead += images[i].Poll(fragmentHandler, fragmentLimit - fragmentsRead);
}
return(fragmentsRead);
}
public static long Read(UnsafeBuffer termBuffer, int offset, FragmentHandler handler, int fragmentsLimit, Header header, ErrorHandler errorHandler)
{
int fragmentsRead = 0;
int capacity = termBuffer.Capacity;
try
{
do
{
int frameLength = FrameDescriptor.FrameLengthVolatile(termBuffer, offset);
if (frameLength <= 0)
{
break;
}
int termOffset = offset;
offset += BitUtil.Align(frameLength, FrameDescriptor.FRAME_ALIGNMENT);
if (!FrameDescriptor.IsPaddingFrame(termBuffer, termOffset))
{
header.SetBuffer(termBuffer, termOffset);
handler(termBuffer, termOffset + DataHeaderFlyweight.HEADER_LENGTH, frameLength - DataHeaderFlyweight.HEADER_LENGTH, header);
++fragmentsRead;
}
} while (fragmentsRead < fragmentsLimit && offset < capacity);
}
catch (Exception t)
{
errorHandler(t);
}
return(Pack(offset, fragmentsRead));
}
public void SetUp()
{
header = new Header(INITIAL_TERM_ID, TERM_BUFFER_CAPACITY);
termBuffer = A.Fake<IAtomicBuffer>();
errorHandler = A.Fake<ErrorHandler>();
handler = A.Fake<FragmentHandler>();
A.CallTo(() => termBuffer.Capacity).Returns(TERM_BUFFER_CAPACITY);
}
public void SetUp()
{
header = new Header(INITIAL_TERM_ID, TERM_BUFFER_CAPACITY);
termBuffer = A.Fake <IAtomicBuffer>();
errorHandler = A.Fake <ErrorHandler>();
handler = A.Fake <FragmentHandler>();
A.CallTo(() => termBuffer.Capacity).Returns(TERM_BUFFER_CAPACITY);
}
public void SetUp()
{
header = new Header(INITIAL_TERM_ID, TERM_BUFFER_CAPACITY);
termBuffer = A.Fake <UnsafeBuffer>();
errorHandler = A.Fake <ErrorHandler>();
handler = A.Fake <FragmentHandler>();
subscriberPosition = A.Fake <IPosition>();
A.CallTo(() => termBuffer.Capacity).Returns(TERM_BUFFER_CAPACITY);
}
/// <summary>
/// Return a reusable, parameterized event loop that calls and idler when no messages are received
/// </summary>
/// <param name="fragmentHandler"> to be called back for each message. </param>
/// <param name="limit"> passed to <seealso cref="Subscription#poll(FragmentHandler, int)"/> </param>
/// <param name="running"> indication for loop </param>
/// <param name="idleStrategy"> to use for loop </param>
/// <returns> loop function </returns>
public static Action<Subscription> SubscriberLoop(FragmentHandler fragmentHandler, int limit, AtomicBoolean running, IIdleStrategy idleStrategy)
{
return subscription =>
{
while (running.Get())
{
idleStrategy.Idle(subscription.Poll(fragmentHandler, limit));
}
};
}
/// <summary>
/// Return a reusable, parameterized event loop that calls and idler when no messages are received
/// </summary>
/// <param name="fragmentHandler"> to be called back for each message. </param>
/// <param name="limit"> passed to <seealso cref="Subscription#poll(FragmentHandler, int)"/> </param>
/// <param name="running"> indication for loop </param>
/// <param name="idleStrategy"> to use for loop </param>
/// <returns> loop function </returns>
public static Action <Subscription> SubscriberLoop(FragmentHandler fragmentHandler, int limit, AtomicBoolean running, IIdleStrategy idleStrategy)
{
return(subscription =>
{
while (running)
{
idleStrategy.Idle(subscription.Poll(fragmentHandler, limit));
}
});
}
public void SetUp()
{
delegateFragmentHandler = A.Fake <FragmentHandler>();
termBuffer = A.Fake <IDirectBuffer>();
adapter = new FragmentAssembler(delegateFragmentHandler);
header = A.Fake <Header>(x => x.Wrapping(new Header(INITIAL_TERM_ID, LogBufferDescriptor.TERM_MIN_LENGTH)));
header.SetBuffer(termBuffer, 0);
A.CallTo(() => termBuffer.GetInt(A <int> ._)).Returns(SESSION_ID);
}
public void SetUp()
{
delegateFragmentHandler = A.Fake<FragmentHandler>();
termBuffer = A.Fake<IDirectBuffer>();
adapter = new FragmentAssembler(delegateFragmentHandler);
header = A.Fake<Header>(x => x.Wrapping(new Header(INITIAL_TERM_ID, LogBufferDescriptor.TERM_MIN_LENGTH)));
header.SetBuffer(termBuffer, 0);
A.CallTo(() => termBuffer.GetInt(A<int>._)).Returns(SESSION_ID);
}
public void Setup()
{
AtomicReadBuffer = new UnsafeBuffer(new byte[READ_BUFFER_CAPACITY]);
Conductor = A.Fake<ClientConductor>();
FragmentHandler = A.Fake<FragmentHandler>();
ImageOneMock = A.Fake<Image>();
ImageTwoMock = A.Fake<Image>();
Header = A.Fake<Header>();
A.CallTo(() => Header.Flags).Returns(FLAGS);
Subscription = new Subscription(Conductor, CHANNEL, STREAM_ID_1, SUBSCRIPTION_CORRELATION_ID);
A.CallTo(() => Conductor.ReleaseSubscription(Subscription));
}
public void Setup()
{
AtomicReadBuffer = new UnsafeBuffer(new byte[READ_BUFFER_CAPACITY]);
Conductor = A.Fake <ClientConductor>();
FragmentHandler = A.Fake <FragmentHandler>();
ImageOneMock = A.Fake <Image>();
ImageTwoMock = A.Fake <Image>();
Header = A.Fake <Header>();
A.CallTo(() => Header.Flags).Returns(FLAGS);
Subscription = new Subscription(Conductor, CHANNEL, STREAM_ID_1, SUBSCRIPTION_CORRELATION_ID);
A.CallTo(() => Conductor.ReleaseSubscription(Subscription));
}
public static int Read(UnsafeBuffer termBuffer, int termOffset, FragmentHandler handler, int fragmentsLimit, Header header, ErrorHandler errorHandler, long currentPosition, IPosition subscriberPosition)
{
int fragmentsRead = 0;
int offset = termOffset;
int capacity = termBuffer.Capacity;
header.Buffer = termBuffer;
try
{
do
{
int frameLength = FrameDescriptor.FrameLengthVolatile(termBuffer, offset);
if (frameLength <= 0)
{
break;
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int frameOffset = offset;
int frameOffset = offset;
offset += BitUtil.Align(frameLength, FrameDescriptor.FRAME_ALIGNMENT);
if (!FrameDescriptor.IsPaddingFrame(termBuffer, frameOffset))
{
header.Offset = frameOffset;
handler(termBuffer, frameOffset + DataHeaderFlyweight.HEADER_LENGTH, frameLength - DataHeaderFlyweight.HEADER_LENGTH, header);
++fragmentsRead;
}
} while (fragmentsRead < fragmentsLimit && offset < capacity);
}
catch (Exception t)
{
errorHandler(t);
}
finally
{
long newPosition = currentPosition + (offset - termOffset);
if (newPosition > currentPosition)
{
subscriberPosition.SetOrdered(newPosition);
}
}
return(fragmentsRead);
}
private static void RoundTripMessages(UnsafeBuffer buffer,
FragmentHandler fragmentHandler, Publication publication, Subscription subscription, int count)
{
for (var i = 0; i < count; i++)
{
do
{
buffer.PutLong(0, Stopwatch.GetTimestamp());
} while (publication.Offer(buffer, 0, MessageLength) < 0L);
PollingIdleStrategy.Reset();
while (subscription.Poll(fragmentHandler, FragmentCountLimit) <= 0)
{
PollingIdleStrategy.Idle();
}
}
}
private static void RoundTripMessages(IMutableDirectBuffer buffer,
FragmentHandler fragmentHandler, Publication publication, Subscription subscription, int count)
{
for (var i = 0; i < count; i++)
{
do
{
buffer.PutLong(0, Stopwatch.GetTimestamp());
} while (publication.Offer(buffer, 0, MessageLength) < 0L);
PollingIdleStrategy.Reset();
while (subscription.Poll(fragmentHandler, FragmentCountLimit) <= 0)
{
PollingIdleStrategy.Idle();
}
}
}
///// <summary>
///// The <seealso cref="FileChannel"/> to the raw log of the Image.
///// </summary>
///// <returns> the <seealso cref="FileChannel"/> to the raw log of the Image. </returns>
//public FileChannel FileChannel()
//{
// return logBuffers.FileChannel();
//}
/// <summary>
/// Poll for new messages in a stream. If new messages are found beyond the last consumed position then they
/// will be delivered to the <seealso cref="FragmentHandler"/> up to a limited number of fragments as specified.
///
/// To assemble messages that span multiple fragments then use <seealso cref="FragmentAssembler"/>.
/// </summary>
/// <param name="fragmentHandler"> to which message fragments are delivered. </param>
/// <param name="fragmentLimit"> for the number of fragments to be consumed during one polling operation. </param>
/// <returns> the number of fragments that have been consumed. </returns>
/// <seealso cref="FragmentAssembler" />
public virtual int Poll(FragmentHandler fragmentHandler, int fragmentLimit)
{
if (_isClosed)
{
return(0);
}
var position = _subscriberPosition.Get();
var termOffset = (int)position & _termLengthMask;
var termBuffer = ActiveTermBuffer(position);
var outcome = TermReader.Read(termBuffer, termOffset, fragmentHandler, fragmentLimit, _header, _errorHandler);
UpdatePosition(position, termOffset, TermReader.Offset(outcome));
return(TermReader.FragmentsRead(outcome));
}
/**
* Poll for new messages in a stream. If new messages are found beyond the last consumed position then they
* will be delivered to the {@link FragmentHandler} up to a limited number of fragments as specified.
*
* To assemble messages that span multiple fragments then use {@link FragmentAssembler}.
*
* @param fragmentHandler to which message fragments are delivered.
* @param fragmentLimit for the number of fragments to be consumed during one polling operation.
* @return the number of fragments that have been consumed.
* @see FragmentAssembler
*/
public int poll(FragmentHandler fragmentHandler, int fragmentLimit)
{
if (isClosed)
{
return(0);
}
long position = subscriberPosition.get();
int termOffset = (int)position & _termLengthMask;
DirectBuffer termBuffer = activeTermBuffer(position);
long outcome = TermReader.Read(termBuffer, termOffset, fragmentHandler, fragmentLimit, header, errorHandler);
updatePosition(position, termOffset, TermReader.Offset(outcome));
return(TermReader.FragmentsRead(outcome));
}
public int Poll(FragmentHandler fragmentHandler, int fragmentLimit)
#endif
{
if (_isClosed)
{
return(0);
}
var position = _subscriberPosition.Get();
return(TermReader.Read(
ActiveTermBuffer(position),
(int)position & _termLengthMask,
fragmentHandler,
fragmentLimit,
_header,
_errorHandler,
position,
_subscriberPosition));
}
/// <summary>
/// Poll the <seealso cref="Image"/>s under the subscription for available message fragments.
/// <para>
/// Each fragment read will be a whole message if it is under MTU length. If larger than MTU then it will come
/// as a series of fragments ordered within a session.
/// </para>
/// <para>
/// To assemble messages that span multiple fragments then use <seealso cref="FragmentAssembler"/>.
///
/// </para>
/// </summary>
/// <param name="fragmentHandler"> callback for handling each message fragment as it is read. </param>
/// <param name="fragmentLimit"> number of message fragments to limit for the poll operation across multiple <seealso cref="Image"/>s. </param>
/// <returns> the number of fragments received </returns>
public int Poll(FragmentHandler fragmentHandler, int fragmentLimit)
{
var images = _images;
var length = images.Length;
var fragmentsRead = 0;
var startingIndex = _roundRobinIndex++;
if (startingIndex >= length)
{
_roundRobinIndex = startingIndex = 0;
}
for (var i = startingIndex; i < length && fragmentsRead < fragmentLimit; i++)
{
fragmentsRead += images[i].Poll(fragmentHandler, fragmentLimit - fragmentsRead);
}
for (var i = 0; i < startingIndex && fragmentsRead < fragmentLimit; i++)
{
fragmentsRead += images[i].Poll(fragmentHandler, fragmentLimit - fragmentsRead);
}
return fragmentsRead;
}
///// <summary>
///// The <seealso cref="FileChannel"/> to the raw log of the Image.
///// </summary>
///// <returns> the <seealso cref="FileChannel"/> to the raw log of the Image. </returns>
//public FileChannel FileChannel()
//{
// return logBuffers.FileChannel();
//}
/// <summary>
/// Poll for new messages in a stream. If new messages are found beyond the last consumed position then they
/// will be delivered to the <seealso cref="FragmentHandler"/> up to a limited number of fragments as specified.
///
/// To assemble messages that span multiple fragments then use <seealso cref="FragmentAssembler"/>.
/// </summary>
/// <param name="fragmentHandler"> to which message fragments are delivered. </param>
/// <param name="fragmentLimit"> for the number of fragments to be consumed during one polling operation. </param>
/// <returns> the number of fragments that have been consumed. </returns>
/// <seealso cref="FragmentAssembler" />
public virtual int Poll(FragmentHandler fragmentHandler, int fragmentLimit)
{
if (_isClosed)
{
return 0;
}
var position = _subscriberPosition.Get();
var termOffset = (int) position & _termLengthMask;
var termBuffer = ActiveTermBuffer(position);
var outcome = TermReader.Read(termBuffer, termOffset, fragmentHandler, fragmentLimit, _header, _errorHandler);
UpdatePosition(position, termOffset, TermReader.Offset(outcome));
return TermReader.FragmentsRead(outcome);
}
/// <summary>
/// Construct an adapter to reassemble message fragments and _delegate on only whole messages.
/// </summary>
/// <param name="fragmentHandler"> onto which whole messages are forwarded. </param>
public FragmentAssembler(FragmentHandler fragmentHandler) : this(fragmentHandler, BufferBuilder.INITIAL_CAPACITY)
{
}
/// <summary>
/// Construct an adapter to reassembly message fragments and _delegate on only whole messages.
/// </summary>
/// <param name="fragmentHandler"> onto which whole messages are forwarded. </param>
/// <param name="initialBufferLength"> to be used for each session. </param>
public FragmentAssembler(FragmentHandler fragmentHandler, int initialBufferLength)
{
_delegate = fragmentHandler;
_builderFunc = ignore => new BufferBuilder(initialBufferLength);
}
/// <summary>
/// Construct an adapter to reassemble message fragments and _delegate on only whole messages.
/// </summary>
/// <param name="fragmentHandler"> onto which whole messages are forwarded. </param>
/// <param name="initialBufferLength"> to be used for each session. </param>
public ImageFragmentAssembler(FragmentHandler fragmentHandler, int initialBufferLength = 0)
{
_delegate = HandlerHelper.ToFragmentHandler(fragmentHandler);
_builder = new BufferBuilder(initialBufferLength);
}
/// <summary>
/// Construct an adapter to reassemble message fragments and _delegate on only whole messages.
/// </summary>
/// <param name="fragmentHandler"> onto which whole messages are forwarded. </param>
/// <param name="initialBufferLength"> to be used for each session. </param>
public ImageFragmentAssembler(FragmentHandler fragmentHandler, int initialBufferLength = BufferBuilder.MIN_ALLOCATED_CAPACITY)
{
_delegate = HandlerHelper.ToFragmentHandler(fragmentHandler);
_builder = new BufferBuilder(initialBufferLength);
}
public static IFragmentHandler ToFragmentHandler(FragmentHandler @delegate)
{
return(new FragmentHandlerWrapper(@delegate));
}
/// <summary>
/// Poll the <seealso cref="Image"/> used for the merging replay and live stream. The <seealso cref="ReplayMerge.DoWork()"/> method
/// will be called before the poll so that processing of the merge can be done.
/// </summary>
/// <param name="fragmentHandler"> to call for fragments </param>
/// <param name="fragmentLimit"> for poll call </param>
/// <returns> number of fragments processed. </returns>
public int Poll(FragmentHandler fragmentHandler, int fragmentLimit)
{
DoWork();
return(image?.Poll(fragmentHandler, fragmentLimit) ?? 0);
}
/// <summary>
/// Construct an adapter to reassemble message fragments and _delegate on only whole messages.
/// </summary>
/// <param name="fragmentHandler"> onto which whole messages are forwarded. </param>
/// <param name="initialBufferLength"> to be used for each session. </param>
public ImageFragmentAssembler(FragmentHandler fragmentHandler, int initialBufferLength)
{
_delegate = fragmentHandler;
_builder = new BufferBuilder(initialBufferLength);
}
public static void Main()
{
// Maximum number of message fragments to receive during a single 'poll' operation
const int fragmentLimitCount = 10;
// The channel (an endpoint identifier) to receive messages from
const string channel = "aeron:udp?endpoint=localhost:40123";
// A unique identifier for a stream within a channel. Stream ID 0 is reserved
// for internal use and should not be used by applications.
const int streamId = 10;
Console.WriteLine("Subscribing to " + channel + " on stream Id " + streamId);
var running = new AtomicBoolean(true);
// Register a SIGINT handler for graceful shutdown.
Console.CancelKeyPress += (s, e) => running.Set(false);
// dataHandler method is called for every new datagram received
FragmentHandler fragmentHandler = (buffer, offset, length, header) =>
{
var data = new byte[length];
buffer.GetBytes(offset, data);
Console.WriteLine($"Received message ({Encoding.UTF8.GetString(data)}) to stream {streamId:D} from session {header.SessionId:x} term id {header.TermId:x} term offset {header.TermOffset:D} ({length:D}@{offset:D})");
// Received the intended message, time to exit the program
running.Set(false);
};
// Create a context, needed for client connection to media driver
// A separate media driver process need to run prior to running this application
var ctx = new Aeron.Context();
// Create an Aeron instance with client-provided context configuration, connect to the
// media driver, and add a subscription for the given channel and stream using the supplied
// dataHandler method, which will be called with new messages as they are received.
// The Aeron and Subscription classes implement AutoCloseable, and will automatically
// clean up resources when this try block is finished.
using (var aeron = Aeron.Connect(ctx))
using (var subscription = aeron.AddSubscription(channel, streamId))
{
IIdleStrategy idleStrategy = new BusySpinIdleStrategy();
// Try to read the data from subscriber
while (running.Get())
{
// poll delivers messages to the dataHandler as they arrive
// and returns number of fragments read, or 0
// if no data is available.
var fragmentsRead = subscription.Poll(fragmentHandler, fragmentLimitCount);
// Give the IdleStrategy a chance to spin/yield/sleep to reduce CPU
// use if no messages were received.
idleStrategy.Idle(fragmentsRead);
}
Console.WriteLine("Press any key...");
Console.ReadLine();
}
}
public FragmentHandlerWrapper(FragmentHandler @delegate)
{
_delegate = @delegate;
}
/// <summary>
/// Construct an adapter to reassemble message fragments and delegate on whole messages.
/// </summary>
/// <param name="fragmentHandler"> onto which whole messages are forwarded. </param>
public ImageFragmentAssembler(FragmentHandler fragmentHandler) : this(fragmentHandler, BufferBuilder.MIN_ALLOCATED_CAPACITY)
{
}
/// <summary>
/// Construct an adapter to reassemble message fragments and delegate on whole messages.
/// </summary>
/// <param name="fragmentHandler"> onto which whole messages are forwarded. </param>
public FragmentAssembler(FragmentHandler fragmentHandler) : this(fragmentHandler, BufferBuilder.INITIAL_CAPACITY)
{
}
///// <summary>
///// The <seealso cref="FileChannel"/> to the raw log of the Image.
///// </summary>
///// <returns> the <seealso cref="FileChannel"/> to the raw log of the Image. </returns>
//public FileChannel FileChannel()
//{
// return logBuffers.FileChannel();
//}
/// <summary>
/// Poll for new messages in a stream. If new messages are found beyond the last consumed position then they
/// will be delivered to the <seealso cref="FragmentHandler"/> up to a limited number of fragments as specified.
///
/// Use a <see cref="FragmentAssembler"/> to assemble messages which span multiple fragments.
/// </summary>
/// <param name="fragmentHandler"> to which message fragments are delivered. </param>
/// <param name="fragmentLimit"> for the number of fragments to be consumed during one polling operation. </param>
/// <returns> the number of fragments that have been consumed. </returns>
/// <seealso cref="FragmentAssembler" />
/// <seealso cref="ImageFragmentAssembler" />
#if DEBUG
public virtual int Poll(FragmentHandler fragmentHandler, int fragmentLimit)
/// <summary>
/// Construct an adapter to reassemble message fragments and _delegate on only whole messages.
/// </summary>
/// <param name="fragmentHandler"> onto which whole messages are forwarded. </param>
/// <param name="initialBufferLength"> to be used for each session. </param>
public FragmentAssembler(FragmentHandler fragmentHandler, int initialBufferLength)
{
_initialBufferLength = initialBufferLength;
_delegate = fragmentHandler;
}
/// <summary>
/// Return a reusable, parameterised event loop that calls a default idler when no messages are received
/// </summary>
/// <param name="fragmentHandler"> to be called back for each message. </param>
/// <param name="limit"> passed to <seealso cref="Subscription#poll(FragmentHandler, int)"/> </param>
/// <param name="running"> indication for loop </param>
/// <returns> loop function </returns>
public static Action<Subscription> SubscriberLoop(FragmentHandler fragmentHandler, int limit, AtomicBoolean running)
{
IIdleStrategy idleStrategy = new BusySpinIdleStrategy();
return SubscriberLoop(fragmentHandler, limit, running, idleStrategy);
}
/// <summary>
/// Construct an adapter to reassembly message fragments and _delegate on only whole messages.
/// </summary>
/// <param name="fragmentHandler"> onto which whole messages are forwarded. </param>
/// <param name="initialBufferLength"> to be used for each session. </param>
public FragmentAssembler(FragmentHandler fragmentHandler, int initialBufferLength)
{
_delegate = fragmentHandler;
_builderFunc = ignore => new BufferBuilder(initialBufferLength);
}
/// <summary>
/// Poll for new messages in a stream. If new messages are found beyond the last consumed position then they
/// will be delivered to the <seealso cref="FragmentHandler"/> up to a limited number of fragments as specified or
/// the maximum position specified.
/// <para>
/// Use a <seealso cref="FragmentAssembler"/> to assemble messages which span multiple fragments.
///
/// </para>
/// </summary>
/// <param name="handler"> to which message fragments are delivered. </param>
/// <param name="limitPosition"> to consume messages up to. </param>
/// <param name="fragmentLimit"> for the number of fragments to be consumed during one polling operation. </param>
/// <returns> the number of fragments that have been consumed. </returns>
/// <seealso cref="FragmentAssembler" />
/// <seealso cref="ImageFragmentAssembler" />
public int BoundedPoll(FragmentHandler handler, long limitPosition, int fragmentLimit)
{
var fragmentHandler = HandlerHelper.ToFragmentHandler(handler);
return(BoundedPoll(fragmentHandler, limitPosition, fragmentLimit));
}
/// <summary>
/// Construct an adapter to reassemble message fragments and _delegate on only whole messages.
/// </summary>
/// <param name="fragmentHandler"> onto which whole messages are forwarded. </param>
/// <param name="initialBufferLength"> to be used for each session. </param>
public FragmentAssembler(FragmentHandler fragmentHandler, int initialBufferLength = 0)
{
_initialBufferLength = initialBufferLength;
_delegate = HandlerHelper.ToFragmentHandler(fragmentHandler);
}
