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