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> /// 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); }