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