public void ValidityTest () { var header1 = new DataflowMessageHeader (); var header2 = new DataflowMessageHeader (2); Assert.IsFalse (header1.IsValid); Assert.IsTrue (header2.IsValid); }
public void EqualityTest () { var header1 = new DataflowMessageHeader (2); var header2 = new DataflowMessageHeader (5); var header3 = new DataflowMessageHeader (2); Assert.AreEqual (header1, header1); Assert.AreEqual (header1.GetHashCode (), header1.GetHashCode ()); Assert.AreEqual (header1, header3); Assert.AreEqual (header1.GetHashCode (), header3.GetHashCode ()); Assert.AreNotEqual (header1, header2); Assert.AreNotEqual (header1.GetHashCode (), header2.GetHashCode ()); }
public void ReleaseReservation(DataflowMessageHeader messageHeader, ITargetBlock <L7PDU> target) { this._L7Pdus.ReleaseReservation(messageHeader, target); }
public PmFrameBase ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <PmFrameBase> target, out bool messageConsumed) { return(this._Frames.ConsumeMessage(messageHeader, target, out messageConsumed)); }
public L7ConversationStatistics ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <L7ConversationStatistics> target, out bool messageConsumed) { return(this._L7ConversationStatistics.ConsumeMessage(messageHeader, target, out messageConsumed)); }
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <L7ConversationStatistics> target) { return(this._L7ConversationStatistics.ReserveMessage(messageHeader, target)); }
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, Bucket messageValue, ISourceBlock<Bucket> source, bool consumeToAccept) { var lines = messageValue.ToLines(); _bufferBlock.Post(lines); return DataflowMessageStatus.Accepted; }
public void ReleaseReservation(DataflowMessageHeader messageHeader, ITargetBlock <L4Conversation> target) { this._L4Conversations.ReleaseReservation(messageHeader, target); }
/// <include file='XmlDocs\CommonXmlDocComments.xml' path='CommonXmlDocComments/Targets/Member[@name="OfferMessage"]/*' /> DataflowMessageStatus ITargetBlock <T> .OfferMessage(DataflowMessageHeader messageHeader, T messageValue, ISourceBlock <T> source, Boolean consumeToAccept) { Contract.Assert(source == _owningSource, "Only valid to be used with the source for which it was created."); return(_target.OfferMessage(messageHeader, messageValue, this, consumeToAccept)); }
public void MaxNumberOfGroupsWithConsumeToAcceptTest () { ITargetBlock<int> block = new BatchBlock<int> (1, new GroupingDataflowBlockOptions { MaxNumberOfGroups = 1 }); var evt = new ManualResetEventSlim (); Func<Task<Tuple<DataflowMessageStatus, bool>>> startTask = () => Task.Factory.StartNew ( () => { var sourceBlock = new TestSourceBlock<int> { ConsumeWaiter = evt.Wait }; var header = new DataflowMessageHeader (1); sourceBlock.AddMessage (header, 1); var status = block.OfferMessage (header, 1, sourceBlock, true); return Tuple.Create (status, sourceBlock.WasConsumed (header)); }); var task1 = startTask (); var task2 = startTask (); Thread.Sleep (100); Assert.IsFalse (task1.IsCompleted); Assert.IsFalse (task2.IsCompleted); evt.Set (); Assert.IsTrue (Task.WaitAll (new Task[] { task1, task2 }, 1000)); CollectionAssert.AreEquivalent ( new[] { Tuple.Create (DataflowMessageStatus.Accepted, true), Tuple.Create (DataflowMessageStatus.DecliningPermanently, false) }, new[] { task1.Result, task2.Result }); }
TSplit ISourceBlock <TSplit> .ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <TSplit> target, out bool messageConsumed) { return(orderCapturer.ConsumeMessage(messageHeader, target, out messageConsumed)); }
public void NonGreedyMaxNumberOfGroupsTest () { var scheduler = new TestScheduler (); var block = new JoinBlock<int, int> ( new GroupingDataflowBlockOptions { MaxNumberOfGroups = 1, Greedy = false, TaskScheduler = scheduler }); var source1 = new TestSourceBlock<int> (); var source2 = new TestSourceBlock<int> (); var header1 = new DataflowMessageHeader (1); source1.AddMessage (header1, 11); source2.AddMessage (header1, 21); Assert.AreEqual (DataflowMessageStatus.Postponed, block.Target1.OfferMessage (header1, 11, source1, false)); Assert.AreEqual (DataflowMessageStatus.Postponed, block.Target2.OfferMessage (header1, 21, source2, false)); scheduler.ExecuteAll (); Assert.IsTrue (source1.WasConsumed (header1)); Assert.IsTrue (source2.WasConsumed (header1)); var header2 = new DataflowMessageHeader (2); Assert.AreEqual (DataflowMessageStatus.DecliningPermanently, block.Target1.OfferMessage (header2, 21, source1, false)); Tuple<int, int> tuple; Assert.IsTrue (block.TryReceive (out tuple)); Assert.AreEqual (Tuple.Create (11, 21), tuple); Assert.IsTrue (block.Completion.Wait (1000)); }
bool ISourceBlock <TSplit> .ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <TSplit> target) { return(orderCapturer.ReserveMessage(messageHeader, target)); }
public void TestSourceCoreSpecifics() { var messageHeader = new DataflowMessageHeader(1); bool consumed; var block = new BufferBlock<int>(); ((ITargetBlock<int>)block).OfferMessage(messageHeader, 42, null, false); var target = new ActionBlock<int>(i => { }); Assert.True(((ISourceBlock<int>)block).ReserveMessage(messageHeader, target)); ((ISourceBlock<int>)block).ReleaseReservation(messageHeader, target); ((ISourceBlock<int>)block).ConsumeMessage(messageHeader, DataflowBlock.NullTarget<int>(), out consumed); Assert.True(consumed); Assert.Equal(expected: 0, actual: block.Count); }
/// <summary> /// Offers the message. /// </summary> /// <param name="messageHeader">The message header.</param> /// <param name="messageValue">The message value.</param> /// <param name="source">The source.</param> /// <param name="consumeToAccept">The consume to accept.</param> /// <returns>DataflowMessageStatus.</returns> public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, LogEntry messageValue, ISourceBlock<LogEntry> source, Boolean consumeToAccept) { return _BatchBlock.OfferMessage(messageHeader, messageValue, source, consumeToAccept); }
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <PmFrameBase> target) { return(this._Frames.ReserveMessage(messageHeader, target)); }
public void BoundedPostponedTest () { var scheduler = new TestScheduler (); var broadcast = new BroadcastBlock<int> ( null, new DataflowBlockOptions { TaskScheduler = scheduler, BoundedCapacity = 1 }); ITargetBlock<int> target = broadcast; var source = new TestSourceBlock<int> (); Assert.IsTrue (broadcast.Post (1)); var header = new DataflowMessageHeader (1); source.AddMessage (header, 2); Assert.AreEqual (DataflowMessageStatus.Postponed, target.OfferMessage (header, 2, source, false)); Assert.IsFalse (source.WasConsumed (header)); scheduler.ExecuteAll (); Assert.IsTrue (source.WasConsumed (header)); }
/// <summary> /// Called by a linked ITargetBlock<TInput> to /// accept and consume a DataflowMessageHeader /// previously offered by this ISourceBlock<TOutput>. /// </summary> /// <param name="messageHeader"> /// The DataflowMessageHeader of the message being consumed. /// </param> /// <param name="target"> /// The ITargetBlock<TInput> consuming the message /// </param> /// <param name="messageConsumed"> /// True if the message was successfully consumed. False otherwise. /// </param> /// <returns> /// The value of the consumed message. This may correspond to a different DataflowMessageHeader /// instance than was previously reserved and passed as the messageHeader to /// ConsumeMessage. The consuming ITargetBlock<TInput> /// must use the returned value instead of the value passed as messageValue through /// OfferMessage. /// If the message requested is not available, the return value will be null. /// </returns> /// <exception> /// System.ArgumentException: The messageHeader is not valid. /// </exception> /// <exception> /// System.ArgumentNullException: The target is null. /// </exception> /// <remarks> /// Only ITargetBlock<TInput> instances linked /// to this ISourceBlock<TOutput> instance may /// use ConsumeMessage, and it must only be used to reserve DataflowMessageHeader /// instances previously offered by this source to the target. /// </remarks> #endregion // Documentation public long ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <long> target, out bool messageConsumed) { throw new NotImplementedException(); }
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, T messageValue, ISourceBlock <T> source, bool consumeToAccept) { _buffer.Push(messageValue); return(DataflowMessageStatus.Accepted); }
/// <include file='XmlDocs\CommonXmlDocComments.xml' path='CommonXmlDocComments/Sources/Member[@name="ConsumeMessage"]/*' /> T ISourceBlock <T> .ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <T> target, out Boolean messageConsumed) { return(_owningSource.ConsumeMessage(messageHeader, this, out messageConsumed)); }
public void ConsumeToAcceptTest () { var source = new TestSourceBlock<int> (); var buffer = new BufferBlock<int> (); var target = (ITargetBlock<int>)buffer; var header = new DataflowMessageHeader (1); source.AddMessage (header, 1); Assert.AreEqual (DataflowMessageStatus.Accepted, target.OfferMessage (header, 1, source, true)); Assert.IsTrue (source.WasConsumed (header)); Assert.IsFalse (source.WasReserved (header)); }
public void TestSourceCoreSpecificsThroughBufferBlock() { var messageHeader = new DataflowMessageHeader(1); bool consumed; var block = new BufferBlock<int>(); ((ITargetBlock<int>)block).OfferMessage(messageHeader, 42, null, false); var nonlinkedTarget = new ActionBlock<int>(i => { }); bool reserved = ((ISourceBlock<int>)block).ReserveMessage(messageHeader, nonlinkedTarget); Assert.False(!reserved, "Failure: SourceCore did not allow a non-linked target to reserve"); ((ISourceBlock<int>)block).ReleaseReservation(messageHeader, nonlinkedTarget); ((ISourceBlock<int>)block).ConsumeMessage(messageHeader, new ActionBlock<int>(i => { }), out consumed); Assert.False(!consumed || block.Count != 0, "Failure: SourceCore did not allow a non-linked target to consume"); }
/// <include file='XmlDocs\CommonXmlDocComments.xml' path='CommonXmlDocComments/Sources/Member[@name="ReserveMessage"]/*' /> bool ISourceBlock <T> .ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <T> target) { return(_owningSource.ReserveMessage(messageHeader, this)); }
public L4Conversation ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <L4Conversation> target, out bool messageConsumed) { return(this._L4Conversations.ConsumeMessage(messageHeader, target, out messageConsumed)); }
/// <include file='XmlDocs\CommonXmlDocComments.xml' path='CommonXmlDocComments/Sources/Member[@name="ReleaseReservation"]/*' /> void ISourceBlock <T> .ReleaseReservation(DataflowMessageHeader messageHeader, ITargetBlock <T> target) { _owningSource.ReleaseReservation(messageHeader, this); }
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <L4Conversation> target) { return(this._L4Conversations.ReserveMessage(messageHeader, target)); }
public void NullTargetTest () { var target = DataflowBlock.NullTarget<int> (); Assert.IsTrue (target.Post (1)); var source = new TestSourceBlock<int> (); var header = new DataflowMessageHeader (1); source.AddMessage (header, 2); Assert.IsFalse (source.WasConsumed (header)); Assert.AreEqual (DataflowMessageStatus.Accepted, target.OfferMessage (header, 2, source, true)); Assert.IsTrue (source.WasConsumed (header)); Assert.IsFalse (target.Completion.Wait (100)); target.Complete (); Assert.IsFalse (target.Completion.Wait (100)); target.Fault (new Exception ()); Assert.IsFalse (target.Completion.Wait (100)); }
public void ReleaseReservation(DataflowMessageHeader messageHeader, ITargetBlock <L7ConversationStatistics> target) { this._L7ConversationStatistics.ReleaseReservation(messageHeader, target); }
void ISourceBlock <Tuple <T1, T2> > .ReleaseReservation( DataflowMessageHeader messageHeader, ITargetBlock <Tuple <T1, T2> > target) { ((ISourceBlock <Tuple <T1, T2> >)_transformManyBlock) .ReleaseReservation(messageHeader, target); }
public L7PDU ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <L7PDU> target, out bool messageConsumed) { return(this._L7Pdus.ConsumeMessage(messageHeader, target, out messageConsumed)); }
bool ISourceBlock <Tuple <T1, T2> > .ReserveMessage( DataflowMessageHeader messageHeader, ITargetBlock <Tuple <T1, T2> > target) { return(((ISourceBlock <Tuple <T1, T2> >)_transformManyBlock) .ReserveMessage(messageHeader, target)); }
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <L7PDU> target) { return(this._L7Pdus.ReserveMessage(messageHeader, target)); }
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, T messageValue, ISourceBlock <T> source, bool consumeToAccept) => _target.OfferMessage(messageHeader, messageValue, source, consumeToAccept);
public void ReleaseReservation(DataflowMessageHeader messageHeader, ITargetBlock <PmFrameBase> target) { this._Frames.ReleaseReservation(messageHeader, target); }
/// <include file='XmlDocs\CommonXmlDocComments.xml' path='CommonXmlDocComments/Targets/Member[@name="OfferMessage"]/*' /> internal DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, TInput messageValue, ISourceBlock <TInput> source, Boolean consumeToAccept) { // Validate arguments if (!messageHeader.IsValid) { throw new ArgumentException(SR.Argument_InvalidMessageHeader, "messageHeader"); } if (source == null && consumeToAccept) { throw new ArgumentException(SR.Argument_CantConsumeFromANullSource, "consumeToAccept"); } Contract.EndContractBlock(); lock (IncomingLock) { // If we shouldn't be accepting more messages, don't. if (_decliningPermanently) { CompleteBlockIfPossible(); return(DataflowMessageStatus.DecliningPermanently); } // We can directly accept the message if: // 1) we are not bounding, OR // 2) we are bounding AND there is room available AND there are no postponed messages AND no messages are currently being transfered to the input queue. // (If there were any postponed messages, we would need to postpone so that ordering would be maintained.) // (Unlike all other blocks, TargetCore can accept messages while processing, because // input message IDs are properly assigned and the correct order is preserved.) if (_boundingState == null || (_boundingState.OutstandingTransfers == 0 && _boundingState.CountIsLessThanBound && _boundingState.PostponedMessages.Count == 0)) { // Consume the message from the source if necessary if (consumeToAccept) { Debug.Assert(source != null, "We must have thrown if source == null && consumeToAccept == true."); bool consumed; messageValue = source.ConsumeMessage(messageHeader, _owningTarget, out consumed); if (!consumed) { return(DataflowMessageStatus.NotAvailable); } } // Assign a message ID - strictly sequential, no gaps. // Once consumed, enqueue the message with its ID and kick off asynchronous processing. long messageId = _nextAvailableInputMessageId.Value++; Debug.Assert(messageId != Common.INVALID_REORDERING_ID, "The assigned message ID is invalid."); if (_boundingState != null) { _boundingState.CurrentCount += 1; // track this new item against our bound } _messages.Enqueue(new KeyValuePair <TInput, long>(messageValue, messageId)); ProcessAsyncIfNecessary(); return(DataflowMessageStatus.Accepted); } // Otherwise, we try to postpone if a source was provided else if (source != null) { Debug.Assert(_boundingState != null && _boundingState.PostponedMessages != null, "PostponedMessages must have been initialized during construction in non-greedy mode."); // Store the message's info and kick off asynchronous processing _boundingState.PostponedMessages.Push(source, messageHeader); ProcessAsyncIfNecessary(); return(DataflowMessageStatus.Postponed); } // We can't do anything else about this message return(DataflowMessageStatus.Declined); } }
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, PmFrameBase messageValue, ISourceBlock <PmFrameBase> source, bool consumeToAccept) { return(this._ProcessFrame.OfferMessage(messageHeader, messageValue, source, consumeToAccept)); }
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, Bucket messageValue, ISourceBlock <Bucket> source, bool consumeToAccept) { messageValue.FeedTarget(_batchBlock); return(DataflowMessageStatus.Accepted); }
public void NonGreedyMaxNumberOfGroupsTest () { var scheduler = new TestScheduler (); var block = new BatchBlock<int> (2, new GroupingDataflowBlockOptions { MaxNumberOfGroups = 1, Greedy = false, TaskScheduler = scheduler }); ITargetBlock<int> target = block; var source1 = new TestSourceBlock<int> (); var source2 = new TestSourceBlock<int> (); var header1 = new DataflowMessageHeader (1); source1.AddMessage (header1, 11); source2.AddMessage (header1, 21); Assert.AreEqual (DataflowMessageStatus.Postponed, target.OfferMessage (header1, 11, source1, false)); Assert.AreEqual (DataflowMessageStatus.Postponed, target.OfferMessage (header1, 21, source2, false)); scheduler.ExecuteAll (); Assert.IsTrue (source1.WasConsumed (header1)); Assert.IsTrue (source2.WasConsumed (header1)); var header2 = new DataflowMessageHeader (2); Assert.AreEqual (DataflowMessageStatus.DecliningPermanently, target.OfferMessage (header2, 21, source1, false)); int[] batch; Assert.IsTrue (block.TryReceive (out batch)); CollectionAssert.AreEquivalent (new[] { 11, 21 }, batch); Assert.IsTrue (block.Completion.Wait (1000)); }
/// <inheritdoc /> public DataflowMessageStatus OfferMessage( DataflowMessageHeader messageHeader, T messageValue, ISourceBlock <T> source, bool consumeToAccept) { ResetTimer(); return(((IPropagatorBlock <T, T[]>)_batchBlock).OfferMessage(messageHeader, messageValue, source, consumeToAccept)); }
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, Bucket bucket, ISourceBlock<Bucket> source, bool consumeToAccept) { Console.WriteLine(bucket.ToString()); return DataflowMessageStatus.Accepted; }
/// <inheritdoc /> public T[] ConsumeMessage(DataflowMessageHeader messageHeader, ITargetBlock <T[]> target, out bool messageConsumed) { return(((IPropagatorBlock <T, T[]>)_batchBlock).ConsumeMessage(messageHeader, target, out messageConsumed)); }
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, Bucket messageValue, ISourceBlock<Bucket> source, bool consumeToAccept) { _preprocessorBlock.Post(messageValue); return DataflowMessageStatus.Accepted; }
/// <inheritdoc /> public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <T[]> target) { return(((IPropagatorBlock <T, T[]>)_batchBlock).ReserveMessage(messageHeader, target)); }
/// <inheritdoc /> public void ReleaseReservation(DataflowMessageHeader messageHeader, ITargetBlock <T[]> target) { ((IPropagatorBlock <T, T[]>)_batchBlock).ReleaseReservation(messageHeader, target); }
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, Bucket messageValue, ISourceBlock<Bucket> source, bool consumeToAccept) { messageValue.FeedTarget(_batchBlock); return DataflowMessageStatus.Accepted; }