public bool ShouldReceive(IStreamIdentity stream, object filterData, object item)
{
if (predicateFunc == null)
{
predicateFunc = RehydrateStaticFuncion(className, methodName);
}
return predicateFunc(stream, filterData, item);
}
public bool ShouldReceive(IStreamIdentity stream, object filterData, object item)
{
if (filters == null || filters.Count == 0) return true;
foreach (var filter in filters)
{
if (filter.ShouldReceive(stream, filter.FilterData, item))
return true; // We got the answer for logical-or predicate
}
return false; // Everybody said 'no'
}
/// <summary>
/// Cursor into a simple queue cache
/// </summary>
/// <param name="cache"></param>
/// <param name="streamIdentity"></param>
/// <param name="logger"></param>
public SimpleQueueCacheCursor(SimpleQueueCache cache, IStreamIdentity streamIdentity, Logger logger)
{
if (cache == null)
{
throw new ArgumentNullException("cache");
}
this.cache = cache;
this.streamIdentity = streamIdentity;
this.logger = logger;
current = null;
SimpleQueueCache.Log(logger, "SimpleQueueCacheCursor New Cursor for {0}, {1}", streamIdentity.Guid, streamIdentity.Namespace);
}
public StreamPosition(IStreamIdentity streamIdentity, StreamSequenceToken sequenceToken)
{
if (streamIdentity == null)
{
throw new ArgumentNullException("streamIdentity");
}
if (sequenceToken == null)
{
throw new ArgumentNullException("sequenceToken");
}
StreamIdentity = streamIdentity;
SequenceToken = sequenceToken;
}
public bool ShouldReceive(IStreamIdentity stream, object filterData, object item)
{
return true;
}
public bool ShouldDeliver(IStreamIdentity stream, object filterData, StreamFilterPredicate shouldReceiveFunc) => _events.Any(item => shouldReceiveFunc(stream, filterData, item));
/// <summary>
/// For test purpose. ConfigureDataGeneratorForStream will configure a data generator for the stream
/// </summary>
/// <param name="streamId"></param>
internal void ConfigureDataGeneratorForStream(IStreamIdentity streamId)
{
(this.receiver as EventHubPartitionGeneratorReceiver)?.ConfigureDataGeneratorForStream(streamId);
}
public bool Equals(MemoryMessageData cachedMessage, IStreamIdentity streamIdentity)
{
int results = cachedMessage.StreamGuid.CompareTo(streamIdentity.Guid);
return(results == 0 && cachedMessage.StreamNamespace == streamIdentity.Namespace);
}
public bool ShouldDeliver(IStreamIdentity stream, object filterData, StreamFilterPredicate shouldReceiveFunc)
{
return(true);
}
public bool ShouldReceive(IStreamIdentity stream, object filterData, object item)
{
return(true);
}
public int Compare(CachedMessage cachedMessage, IStreamIdentity streamIdentity)
{
int results = cachedMessage.StreamGuid.CompareTo(streamIdentity.Guid);
return results != 0 ? results : String.Compare(cachedMessage.StreamNamespace, streamIdentity.Namespace, StringComparison.Ordinal);
}
/// <summary>
/// Should be called when an event could not be delivered to a consumer, after exhausting retry attempts.
/// </summary>
public Task OnDeliveryFailure(GuidId subscriptionId, string streamProviderName, IStreamIdentity streamIdentity,
StreamSequenceToken sequenceToken)
{
return(TaskDone.Done);
}
public Cursor(IEventHubQueueCache cache, IStreamIdentity streamIdentity, StreamSequenceToken token)
{
this.cache = cache;
this.cursor = cache.GetCursor(streamIdentity, token);
}
// Function is not static, so cannot be used as a filter predicate function.
public bool BadFunc(IStreamIdentity stream, object filterData, object item)
{
return(true);
}
/// <summary>
/// Checks to see if the cached message is part of the provided stream
/// </summary>
/// <param name="cachedMessage"></param>
/// <param name="comparer"></param>
/// <param name="streamIdentity"></param>
/// <returns></returns>
public static bool Equals <TCachedMessage>(this ICacheDataComparer <TCachedMessage> comparer, IStreamIdentity streamIdentity, TCachedMessage cachedMessage)
{
return(comparer.Equals(cachedMessage, streamIdentity));
}
IQueueCacheCursor IQueueCache.GetCacheCursor(IStreamIdentity streamIdentity, StreamSequenceToken token)
{
m_Receiver.SubscribeTo(streamIdentity.Namespace, token as EventStoreStreamSequenceToken);
return(base.GetCacheCursor(streamIdentity, token));
}
public Task <IEnumerable <StreamSubscription> > GetSubscriptions(string streamProviderName, IStreamIdentity streamIdentity)
{
var streamId = StreamId.GetStreamId(streamIdentity.Guid, streamProviderName, streamIdentity.Namespace);
return(streamPubSub.GetAllSubscriptions(streamId).ContinueWith(subs => subs.Result.AsEnumerable()));
}
public bool Equals(CachedMessage cachedMessage, IStreamIdentity streamIdentity)
{
var results = cachedMessage.StreamGuid.CompareTo(streamIdentity.Guid);
return(results == 0 && string.Compare(cachedMessage.StreamNamespace, streamIdentity.Namespace, StringComparison.Ordinal) == 0);
}
/// <inheritdoc />
public void ConfigureDataGeneratorForStream(IStreamIdentity streamId)
{
(this.generator as IStreamDataGeneratingController)?.AddDataGeneratorForStream(streamId);
}
/// <summary> /// Initializes a new instance of the <see cref="StreamId"/> struct. /// </summary> /// <param name="streamIdentity">The stream identity.</param> public static StreamId Create(IStreamIdentity streamIdentity) => Create(streamIdentity.Namespace, streamIdentity.Guid);
public Cursor(PooledQueueCache <MemoryMessageData, MemoryMessageData> cache, IStreamIdentity streamIdentity,
StreamSequenceToken token)
{
this.cache = cache;
cursor = cache.GetCursor(streamIdentity, token);
}
public Cursor(IStreamIdentity streamIdentity)
{
StreamIdentity = streamIdentity;
State = CursorStates.Unset;
}
public Cursor(PooledQueueCache cache, IStreamIdentity streamIdentity,
StreamSequenceToken token)
{
this.cache = cache;
cursor = cache.GetCursor(streamIdentity, token);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="streamId"></param>
/// <param name="randomNumber"></param>
public StreamRandomPlacementArg(IStreamIdentity streamId, int randomNumber)
{
this.StreamId = streamId;
this.RandomNumber = randomNumber;
}
public object GetCursor(IStreamIdentity streamIdentity, StreamSequenceToken sequenceToken)
{
return(cache.GetCursor(streamIdentity, sequenceToken));
}
public Task OnSubscriptionFailure(GuidId subscriptionId, string streamProviderName, IStreamIdentity streamIdentity,
StreamSequenceToken sequenceToken)
{
// TODO: Subscription Failure is not implemented.
return(TaskDone.Done);
}
public IQueueCacheCursor GetCacheCursor(IStreamIdentity streamIdentity, StreamSequenceToken token)
{
return(new Cursor(this.cache, streamIdentity, token));
}
/// <summary>
/// Tries to find the first message in the block that is part of the provided stream.
/// </summary>
/// <param name="streamIdentity"></param>
/// <param name="comparer"></param>
/// <param name="index"></param>
/// <returns></returns>
public bool TryFindFirstMessage(IStreamIdentity streamIdentity, ICacheDataComparer <TCachedMessage> comparer, out int index)
{
return(TryFindNextMessage(readIndex, streamIdentity, comparer, out index));
}
internal void StopProducingOnStream(IStreamIdentity streamId)
{
(this.receiver as EventHubPartitionGeneratorReceiver)?.StopProducingOnStream(streamId);
}
public Task OnSubscriptionFailure(GuidId subscriptionId, string streamProviderName, IStreamIdentity streamIdentity,
StreamSequenceToken sequenceToken)
{
return TaskDone.Done;
}
public Task OnSubscriptionFailure(GuidId subscriptionId, string streamProviderName, IStreamIdentity streamIdentity, StreamSequenceToken sequenceToken)
{
_logger.AutoError($"provider name: {streamProviderName}, sub id: {subscriptionId}, stream id: {streamIdentity}, token: {sequenceToken}");
return TaskDone.Done;
}
public async Task <StreamSubscription> AddSubscription(string streamProviderName, IStreamIdentity streamIdentity, GrainReference grainRef)
{
var consumer = grainRef.AsReference <IStreamConsumerExtension>();
var streamId = StreamId.GetStreamId(streamIdentity.Guid, streamProviderName, streamIdentity.Namespace);
var subscriptionId = streamPubSub.CreateSubscriptionId(
streamId, consumer);
await streamPubSub.RegisterConsumer(subscriptionId, streamId, streamProviderName, consumer, null);
var newSub = new StreamSubscription(subscriptionId.Guid, streamProviderName, streamId, grainRef.GrainId);
return(newSub);
}
public bool ShouldDeliver(IStreamIdentity stream, object filterData, StreamFilterPredicate shouldReceiveFunc)
{
throw new NotSupportedException();
}
public async Task RemoveSubscription(string streamProviderName, IStreamIdentity streamId, Guid subscriptionId)
{
await streamPubSub.UnregisterConsumer(GuidId.GetGuidId(subscriptionId), StreamId.GetStreamId(streamId.Guid, streamProviderName, streamId.Namespace), streamProviderName);
}
public bool ShouldDeliver(IStreamIdentity stream, object filterData, StreamFilterPredicate shouldReceiveFunc)
{
// If there is something in this batch that the consumer is interested in, we should send it
// else the consumer is not interested in any of these events, so don't send.
return(_events.Any(item => shouldReceiveFunc(stream, filterData, item)));
}
public Cursor(PooledQueueCache<GeneratedBatchContainer, CachedMessage> cache, IStreamIdentity streamIdentity, StreamSequenceToken token)
{
this.cache = cache;
cursor = cache.GetCursor(streamIdentity, token);
}
//public virtual IQueueCacheCursor GetCacheCursor(Guid streamGuid, string streamNamespace, StreamSequenceToken token)
public virtual IQueueCacheCursor GetCacheCursor(IStreamIdentity streamIdentity, StreamSequenceToken token)
{
if (token != null && !(token is EventSequenceToken))
{
// Null token can come from a stream subscriber that is just interested to
// start consuming from latest (the most recent event added to the cache).
throw new ArgumentOutOfRangeException(nameof(token), "token must be of type EventSequenceToken");
}
var cursor = new TimedQueueCacheCursor(this, streamIdentity.Guid, streamIdentity.Namespace, _logger);
InitializeCursor(cursor, token);
return cursor;
}
/// <inheritdoc />
public void StopProducingOnStream(IStreamIdentity streamId)
{
(this.generator as IStreamDataGeneratingController)?.StopProducingOnStream(streamId);
}
