public Task BecomeProducer(Guid streamId, string providerToUse) { _logger.Info("Producer.BecomeProducer"); if (streamId == null) { throw new ArgumentNullException("streamId"); } if (String.IsNullOrEmpty(providerToUse)) { throw new ArgumentNullException("providerToUse"); } IStreamProvider streamProvider = GetStreamProvider(providerToUse); IAsyncStream<int> stream = streamProvider.GetStream<int>(streamId, ConsumerEventCountingGrain.StreamNamespace); _producer = stream; return TaskDone.Done; }
public static IAsyncObserver <TSource>[] Zip <TSource>(IAsyncObserver <IList <TSource> > observer, int count) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (count < 0) { throw new ArgumentOutOfRangeException(nameof(count)); } var gate = new AsyncLock(); var queues = new Queue <TSource> [count]; var isDone = new bool[count]; var res = new IAsyncObserver <TSource> [count]; IAsyncObserver <TSource> CreateObserver(int index) => Create <TSource>( async x => { using (await gate.LockAsync().ConfigureAwait(false)) { queues[index].Enqueue(x); if (queues.All(queue => queue.Count > 0)) { var list = new TSource[count]; for (var i = 0; i < count; i++) { list[i] = queues[i].Dequeue(); } await observer.OnNextAsync(list).ConfigureAwait(false); } else { var allDone = true; for (var i = 0; i < count; i++) { if (i != index && !isDone[i]) { allDone = false; break; } } if (allDone) { await observer.OnCompletedAsync().ConfigureAwait(false); } } } }, async ex => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } }, async() => { using (await gate.LockAsync().ConfigureAwait(false)) { isDone[index] = true; var allDone = true; for (var i = 0; i < count; i++) { if (!isDone[i]) { allDone = false; break; } } if (allDone) { await observer.OnCompletedAsync().ConfigureAwait(false); } } } ); for (var i = 0; i < count; i++) { queues[i] = new Queue <TSource>(); res[i] = CreateObserver(i); } return(res); }
public static async Task <(IAsyncObserver <TSource>, IAsyncDisposable)> ObserveOn <TSource>(this IAsyncObserver <TSource> observer, IAsyncScheduler scheduler) { if (observer == null)
public Observer(IAsyncObserver <T> observer, Action action) : base(observer) { _action = action; }
public Task <StreamSubscriptionHandle <T> > SubscribeAsync(IAsyncObserver <T> observer, StreamSequenceToken token, StreamFilterPredicate filterFunc = null, object filterData = null) { return(GetConsumerInterface().SubscribeAsync(observer, token, filterFunc, filterData)); }
public AnonymousAsyncSubject(IAsyncObserver <T> observer, IAsyncObservable <T> observable) { _observer = observer; _observable = observable; }
public ValueTask SubscribeAsync(IAsyncObserver <T> observer, CancellationToken token) { var o = new Observer(observer, _count); return(_source.SubscribeAsync(o, token)); }
internal StreamSubscriptionHandleImpl <T> SetObserver <T>(GuidId subscriptionId, StreamImpl <T> stream, IAsyncObserver <T> observer, IStreamFilterPredicateWrapper filter) { if (null == stream) { throw new ArgumentNullException("stream"); } if (null == observer) { throw new ArgumentNullException("observer"); } try { if (logger.IsVerbose) { logger.Verbose("{0} AddObserver for stream {1}", providerRuntime.ExecutingEntityIdentity(), stream); } // Note: The caller [StreamConsumer] already handles locking for Add/Remove operations, so we don't need to repeat here. IStreamObservers obs = allStreamObservers.GetOrAdd(subscriptionId, new ObserversCollection <T>()); var wrapper = new StreamSubscriptionHandleImpl <T>(subscriptionId, observer, stream, filter); ((ObserversCollection <T>)obs).SetObserver(wrapper); return(wrapper); } catch (Exception exc) { logger.Error((int)ErrorCode.StreamProvider_AddObserverException, String.Format("{0} StreamConsumerExtension.AddObserver({1}) caugth exception.", providerRuntime.ExecutingEntityIdentity(), stream), exc); throw; } }
/// <summary> /// Invokes the observer's method corresponding to the notification. /// </summary> /// <param name="observer">Observer to invoke the notification on.</param> /// <returns>Task indicating the completion of invoking the observer method.</returns> public abstract Task AcceptAsync(IAsyncObserver <T> observer);
public Observer(IAsyncObserver <T> observer) { _observer = observer; }
public static Task <IAsyncDisposable> SubscribeSafeAsync <T>(this IAsyncObservable <T> source, IAsyncObserver <T> observer) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (observer == null) { throw new ArgumentNullException(nameof(observer)); } return(CoreAsync()); async Task <IAsyncDisposable> CoreAsync() { try { return(await source.SubscribeAsync(observer).ConfigureAwait(false)); } catch (Exception ex) { await observer.OnErrorAsync(ex).ConfigureAwait(false); return(AsyncDisposable.Nop); } } }
public async Task <StreamSubscriptionHandle <T> > SubscribeAsync( IAsyncObserver <T> observer, StreamSequenceToken token, StreamFilterPredicate filterFunc = null, object filterData = null) { if (token != null && !IsRewindable) { throw new ArgumentNullException("token", "Passing a non-null token to a non-rewindable IAsyncObservable."); } if (observer is GrainReference) { throw new ArgumentException("On-behalf subscription via grain references is not supported. Only passing of object references is allowed.", "observer"); } if (logger.IsVerbose) { logger.Verbose("Subscribe Observer={0} Token={1}", observer, token); } await BindExtensionLazy(); IStreamFilterPredicateWrapper filterWrapper = null; if (filterFunc != null) { filterWrapper = new FilterPredicateWrapperData(filterData, filterFunc); } if (logger.IsVerbose) { logger.Verbose("Subscribe - Connecting to Rendezvous {0} My GrainRef={1} Token={2}", pubSub, myGrainReference, token); } GuidId subscriptionId = pubSub.CreateSubscriptionId(stream.StreamId, myGrainReference); // Optimistic Concurrency: // In general, we should first register the subsription with the pubsub (pubSub.RegisterConsumer) // and only if it succeeds store it locally (myExtension.SetObserver). // Basicaly, those 2 operations should be done as one atomic transaction - either both or none and isolated from concurrent reads. // BUT: there is a distributed race here: the first msg may arrive before the call is awaited // (since the pubsub notifies the producer that may immideately produce) // and will thus not find the subriptionHandle in the extension, basically violating "isolation". // Therefore, we employ Optimistic Concurrency Control here to guarantee isolation: // we optimisticaly store subscriptionId in the handle first before calling pubSub.RegisterConsumer // and undo it in the case of failure. // There is no problem with that we call myExtension.SetObserver too early before the handle is registered in pub sub, // since this subscriptionId is unique (random Guid) and no one knows it anyway, unless successfully subscribed in the pubsub. var subriptionHandle = myExtension.SetObserver(subscriptionId, stream, observer, token, filterWrapper); try { await pubSub.RegisterConsumer(subscriptionId, stream.StreamId, streamProviderName, myGrainReference, filterWrapper); return(subriptionHandle); } catch (Exception) { // Undo the previous call myExtension.SetObserver. myExtension.RemoveObserver(subscriptionId); throw; } }
public async ValueTask SubscribeAsync(IAsyncObserver <T> observer, CancellationToken token) { await observer.DisposeAsync().ConfigureAwait(false); }
private static async Task <IAsyncDisposable> WindowCore <TSource>(IAsyncObservable <TSource> source, IAsyncObserver <IAsyncObservable <TSource> > observer, Func <IAsyncObserver <IAsyncObservable <TSource> >, IAsyncDisposable, (IAsyncObserver <TSource>, IAsyncDisposable)> createObserver)
public Observer(IAsyncObserver <T> observer, Func <T, ValueTask <bool> > predicate) { _observer = observer; _predicate = predicate; }
public static (IAsyncObserver <TSource>, IAsyncObserver <TUntil>) TakeUntil <TSource, TUntil>(IAsyncObserver <TSource> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } var gate = new AsyncLock(); return ( Create <TSource>( async x => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnNextAsync(x).ConfigureAwait(false); } }, async ex => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } }, async() => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnCompletedAsync().ConfigureAwait(false); } } ), Create <TUntil>( async y => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnCompletedAsync().ConfigureAwait(false); } }, async ex => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } }, () => Task.CompletedTask ) ); }
public void Register <T>(Stream.SubKey subKey, IAsyncObserver <T> observer) { _dObservers[subKey] = new Observer <T>(_serializer, observer); }
internal void Clear() { observer = null; }
public Observer(FakeSerializer serializer, IAsyncObserver <T> observer) { _serializer = serializer; _observer = observer; }
public Observer(IAsyncObserver <T> observer, int count) { _observer = observer; _remaining = count; }
public static IAsyncObserver <TSource>[] Amb <TSource>(IAsyncObserver <TSource> observer, IAsyncDisposable[] subscriptions) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (subscriptions == null) { throw new ArgumentNullException(nameof(subscriptions)); } var gate = new AsyncLock(); var winner = default(int?); var count = subscriptions.Length; async Task ElectWinnerAsync(int index) { winner = index; var dispose = new List <Task>(count - 1); for (var i = 0; i < count; i++) { if (i != index) { dispose.Add(subscriptions[i].DisposeAsync().AsTask()); } } await Task.WhenAll(dispose).ConfigureAwait(false); } IAsyncObserver <TSource> CreateObserver(int index) => Create <TSource>( async x => { using (await gate.LockAsync().ConfigureAwait(false)) { if (winner == null) { await ElectWinnerAsync(index).ConfigureAwait(false); } if (winner == index) { await observer.OnNextAsync(x).ConfigureAwait(false); } } }, async ex => { using (await gate.LockAsync().ConfigureAwait(false)) { if (winner == null) { await ElectWinnerAsync(index).ConfigureAwait(false); } if (winner == index) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } } }, async() => { using (await gate.LockAsync().ConfigureAwait(false)) { if (winner == null) { await ElectWinnerAsync(index).ConfigureAwait(false); } if (winner == index) { await observer.OnCompletedAsync().ConfigureAwait(false); } } } ); var res = new IAsyncObserver <TSource> [count]; for (var i = 0; i < count; i++) { res[i] = CreateObserver(i); } return(res); }
public Task <StreamSubscriptionHandle <T> > SubscribeAsync(IAsyncObserver <T> observer) { return(GetConsumerInterface().SubscribeAsync(observer, null)); }
public static (IAsyncObserver <TSource>, IAsyncObserver <TSource>) Amb <TSource>(IAsyncObserver <TSource> observer, IAsyncDisposable first, IAsyncDisposable second) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } if (first == null) { throw new ArgumentNullException(nameof(first)); } if (second == null) { throw new ArgumentNullException(nameof(second)); } var gate = new AsyncLock(); var state = AmbState.None; return ( Create <TSource>( async x => { using (await gate.LockAsync().ConfigureAwait(false)) { if (state == AmbState.None) { state = AmbState.First; await second.DisposeAsync().ConfigureAwait(false); } if (state == AmbState.First) { await observer.OnNextAsync(x).ConfigureAwait(false); } } }, async ex => { using (await gate.LockAsync().ConfigureAwait(false)) { if (state == AmbState.None) { state = AmbState.First; await second.DisposeAsync().ConfigureAwait(false); } if (state == AmbState.First) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } } }, async() => { using (await gate.LockAsync().ConfigureAwait(false)) { if (state == AmbState.None) { state = AmbState.First; await second.DisposeAsync().ConfigureAwait(false); } if (state == AmbState.First) { await observer.OnCompletedAsync().ConfigureAwait(false); } } } ), Create <TSource>( async x => { using (await gate.LockAsync().ConfigureAwait(false)) { if (state == AmbState.None) { state = AmbState.Second; await first.DisposeAsync().ConfigureAwait(false); } if (state == AmbState.Second) { await observer.OnNextAsync(x).ConfigureAwait(false); } } }, async ex => { using (await gate.LockAsync().ConfigureAwait(false)) { if (state == AmbState.None) { state = AmbState.Second; await first.DisposeAsync().ConfigureAwait(false); } if (state == AmbState.Second) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } } }, async() => { using (await gate.LockAsync().ConfigureAwait(false)) { if (state == AmbState.None) { state = AmbState.Second; await first.DisposeAsync().ConfigureAwait(false); } if (state == AmbState.Second) { await observer.OnCompletedAsync().ConfigureAwait(false); } } } ) ); }
public ValueTask SubscribeAsync(IAsyncObserver <T> observer) { var o = new Observer(observer, _action); return(_source.SubscribeAsync(o)); }
public OuterObserver(IAsyncObserver <T> observer) : base(observer) { }
public void Invalidate() { streamImpl = null; observer = null; }
public static ValueTask <IAsyncDisposable> Return <TSource>(IAsyncObserver <TSource> observer, TSource value) => Return(observer, value, ImmediateAsyncScheduler.Instance);
public static ValueTask <IAsyncDisposable> Throw <TSource>(IAsyncObserver <TSource> observer, Exception error) => Throw(observer, error, ImmediateAsyncScheduler.Instance);
public static IAsyncObserver <TSource> TakeLastBuffer <TSource>(IAsyncObserver <IList <TSource> > observer, TimeSpan duration) => TakeLastBuffer(observer, duration, Clock.Default);
public Task <StreamSubscriptionHandle <T> > SubscribeAsync(IAsyncObserver <T> observer) { return(SubscribeAsyncImpl(observer, null, null)); }
public static (IAsyncObserver <TSource>, IAsyncObserver <TSample>) Sample <TSource, TSample>(IAsyncObserver <TSource> observer) { if (observer == null) { throw new ArgumentNullException(nameof(observer)); } var gate = new AsyncLock(); var hasValue = false; var value = default(TSource); var atEnd = false; async ValueTask OnSampleAsync() { using (await gate.LockAsync().ConfigureAwait(false)) { if (hasValue) { hasValue = false; await observer.OnNextAsync(value).ConfigureAwait(false); } if (atEnd) { await observer.OnCompletedAsync().ConfigureAwait(false); } } } return ( Create <TSource>( async x => { using (await gate.LockAsync().ConfigureAwait(false)) { hasValue = true; value = x; } }, async ex => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } }, async() => { using (await gate.LockAsync().ConfigureAwait(false)) { atEnd = true; } } ), Create <TSample>( _ => OnSampleAsync(), async ex => { using (await gate.LockAsync().ConfigureAwait(false)) { await observer.OnErrorAsync(ex).ConfigureAwait(false); } }, OnSampleAsync ) ); }