Task <IDisposable> IAsyncNetworkBus.SubscribeAsync <TMessage>(Func <TMessage, Task> func, Guid?referenceId) => Task.FromResult((IDisposable)Connection.SubscribeAsync(INetworkBus.GetSubject <TMessage>(referenceId), async(s, e) => { var request = new TMessage(); request.SetData(e.Message.Data); await func(request); }));
public ShardService(IShardStorage storage, INetworkBus bus, IServiceLocator locator, ITimer timer) { this.storage = storage; this.bus = bus; this.locator = locator; this.timer = timer; }
IEnumerable <TMessageResponse> INetworkBus.PublishAndWaitForReplyEnumerable <TMessageRequest, TMessageResponse>(TMessageRequest message, Guid?referenceId, int timeout) { var observable = Connection.Observe(INetworkBus.GetSubject <TMessageResponse>(referenceId)) .Select(msg => { var response = new TMessageResponse(); response.SetData(msg.Data); return(response); }) .Timeout(TimeSpan.FromMilliseconds(timeout == -1 ? int.MaxValue : timeout)) .Catch <TMessageResponse, TimeoutException>(_ => Observable.Empty <TMessageResponse>()); using var _ = observable.Subscribe(); Publish(message, referenceId); foreach (var response in observable.ToEnumerable()) { yield return(response); if (response.IsLastMessage) { yield break; } } }
IDisposable INetworkBus.Subscribe <TMessage>(Action <TMessage> func, Guid?referenceId) => Connection.SubscribeAsync(INetworkBus.GetSubject <TMessage>(referenceId), (s, e) => { var request = new TMessage(); request.SetData(e.Message.Data); func(request); });
public ProposerService(IProposerStorage storage, IServiceLocator locator, INetworkBus bus, ITimer timer) { this.locator = locator; this.bus = bus; this.timer = timer; this.storage = storage; }
public AcceptorService(INetworkBus bus, ITimer timer, ITxExecutor executor, IAcceptorStorage storage) { this.bus = bus; this.timer = timer; this.executor = executor; this.storage = storage; }
Task <IDisposable> IAsyncNetworkBus.SubscribeAndReplyAsync <TMessageRequest>(Func <TMessageRequest, Task <IMessage> > func, Guid?referenceId) => Task.FromResult((IDisposable)Connection.SubscribeAsync(INetworkBus.GetSubject <TMessageRequest>(referenceId), async(s, e) => { var request = new TMessageRequest(); request.SetData(e.Message.Data); var response = await func(request); await PublishAsync(response, referenceId); }));
IDisposable INetworkBus.SubscribeAndReply <TMessageRequest>(Func <TMessageRequest, IMessage> func, Guid?referenceId) => Connection.SubscribeAsync(INetworkBus.GetSubject <TMessageRequest>(referenceId), (s, e) => { var request = new TMessageRequest(); request.SetData(e.Message.Data); var response = func(request); Publish(response, referenceId); });
IDisposable INetworkBus.SubscribeAndReplyEnumerable <TMessageRequest, TMessageResponse>(Func <TMessageRequest, IEnumerable <TMessageResponse> > func, Guid?referenceId) => Connection.SubscribeAsync(INetworkBus.GetSubject <TMessageRequest>(), (s, e) => { var request = new TMessageRequest(); request.SetData(e.Message.Data); foreach (var response in func(request)) { Publish(response, referenceId); } });
TMessageResponse INetworkBus.PublishAndWaitForReply <TMessageRequest, TMessageResponse>(TMessageRequest message, Guid?referenceId, int timeout) { using var cancellationTokenSource = new CancellationTokenSource(timeout); var returnLock = new TaskCompletionSource <TMessageResponse>(TaskCreationOptions.RunContinuationsAsynchronously); using var sub = Connection.SubscribeAsync(INetworkBus.GetSubject <TMessageResponse>(referenceId), (s, e) => { var response = new TMessageResponse(); response.SetData(e.Message.Data); returnLock.SetResult(response); }); Publish(message, referenceId); return(returnLock.Task.WaitAsync(cancellationTokenSource.Token).GetAwaiter().GetResult()); }
async Task <TMessageResponse> IAsyncNetworkBus.PublishAndWaitForReplyAsync <TMessageRequest, TMessageResponse>(TMessageRequest message, Guid?referenceId, int timeout) { using var cancellationTokenSource = new CancellationTokenSource(timeout); var returnLock = new TaskCompletionSource <TMessageResponse>(TaskCreationOptions.RunContinuationsAsynchronously); using var sub = Connection.SubscribeAsync(INetworkBus.GetSubject <TMessageResponse>(referenceId), (s, e) => { // TODO: try { var response = new TMessageResponse(); response.SetData(e.Message.Data); returnLock.SetResult(response); } catch (Exception) { } }); await PublishAsync(message, referenceId); return(await returnLock.Task.WaitAsync(cancellationTokenSource.Token)); }
public void Publish <TMessage>(TMessage message, Guid?referenceId = null) where TMessage : notnull, IMessage => Connection.Publish(INetworkBus.GetSubject(message, referenceId), message.GetData().ToArray());
public static IDisposable RegisterEnumerableHandler <TMessageRequest, TMessageResponse>(this INetworkBus bus, IEnumerableMessageHandler <TMessageRequest, TMessageResponse> handler, Guid?referenceId = null) where TMessageRequest : notnull, IMessage, new() where TMessageResponse : notnull, IEnumerableMessage, new() { return(bus.SubscribeAndReplyEnumerable <TMessageRequest, TMessageResponse>(handler.HandleAsync, referenceId)); }
public Task PublishAsync <TMessage>(TMessage message, Guid?referenceId) where TMessage : notnull, IMessage => Task.Run(() => Connection.Publish(INetworkBus.GetSubject(message, referenceId), message.GetData().ToArray()));
public static TMessageResponse?PublishAndWaitForExclusiveResponse <TMessageRequest, TMessageResponse>(this INetworkBus bus, TMessageRequest message, int timeout = -1) where TMessageRequest : notnull, IMessage, new() where TMessageResponse : class, IMessage, new() { using var firstResponseCancellationTokenSource = new CancellationTokenSource(timeout); var firstResponseLock = new TaskCompletionSource <ExclusiveResponseMessage <TMessageRequest> >(TaskCreationOptions.RunContinuationsAsynchronously); using var _ = bus.Subscribe <ExclusiveResponseMessage <TMessageRequest> >(msg => { firstResponseLock.SetResult(msg); }, null); bus.Publish(new ExclusiveRequestMessage <TMessageRequest>(), null); var firstResponse = firstResponseLock.Task.WaitAsync(firstResponseCancellationTokenSource.Token).WaitAndUnwrapException(); if (firstResponse == null) { return(null); } using var responseCancellationTokenSource = new CancellationTokenSource(timeout); var responseLock = new TaskCompletionSource <ExclusiveAcceptedResponseMessage <TMessageResponse> >(TaskCreationOptions.RunContinuationsAsynchronously); using var __ = bus.Subscribe <ExclusiveAcceptedResponseMessage <TMessageResponse> >(msg => { responseLock.SetResult(msg); }, firstResponse.ReferenceId); bus.Publish(new ExclusiveAcceptedRequestMessage <TMessageRequest>(message), firstResponse.ReferenceId); var response = responseLock.Task.WaitAsync(responseCancellationTokenSource.Token).WaitAndUnwrapException(); return(response.Response); }
public static IDisposable RegisterReceiver <TMessageRequest>(this INetworkBus bus, IMessageReceiver <TMessageRequest> handler, Guid?referenceId = null) where TMessageRequest : notnull, IMessage, new() { return(bus.Subscribe <TMessageRequest>(message => handler.HandleAsync(message), referenceId)); }
public static IDisposable RegisterExclusiveHandler <TMessageRequest, TMessageResponse>(this INetworkBus bus, IExclusiveMessageHandler <TMessageRequest, TMessageResponse> handler, Guid referenceId) where TMessageRequest : notnull, IMessage, new() where TMessageResponse : notnull, IMessage, new() { return(bus.SubscribeAndReplyToExclusive <TMessageRequest, TMessageResponse>(handler.CanHandle, handler.HandleAsync, referenceId)); }
public SimnetClient(INetworkBus networkBus, string clientId) { _networkBus = networkBus; _subscriptions = new Dictionary <string, Subscription>(); ClientId = clientId; }
public ClientService(IServiceLocator locator, INetworkBus bus, ITimer timer) { this.locator = locator; this.bus = bus; this.timer = timer; }
public static IDisposable SubscribeAndReplyEnumerable <TMessageRequest, TMessageResponse>(this INetworkBus bus, Func <TMessageRequest, IAsyncEnumerable <TMessageResponse> > func, Guid?referenceId) where TMessageRequest : notnull, IMessage, new() where TMessageResponse : notnull, IEnumerableMessage, new() { return(bus.SubscribeAndReplyEnumerable <TMessageRequest, TMessageResponse>(message => func(message).ToEnumerable(), referenceId)); }
public static IDisposable SubscribeAndReply <TMessageRequest, TMessageResponse>(this INetworkBus bus, Func <TMessageRequest, Task <TMessageResponse> > func, Guid?referenceId) where TMessageRequest : notnull, IMessage, new() where TMessageResponse : notnull, IMessage, new() { return(bus.SubscribeAndReply <TMessageRequest>(message => func(message).WaitAndUnwrapException(), referenceId)); }
public static IDisposable SubscribeAndReplyToExclusive <TMessageRequest, TMessageResponse>(this INetworkBus bus, Func <TMessageRequest, Task <bool> > canReply, Func <TMessageRequest, Task <TMessageResponse> > func, Guid requestReferenceId) where TMessageRequest : notnull, IMessage, new() where TMessageResponse : notnull, IMessage, new() { var disposable1 = bus.Subscribe <ExclusiveRequestMessage <TMessageRequest> >(async message => { if (await canReply(message.Request)) { bus.Publish(new ExclusiveResponseMessage <TMessageRequest>(requestReferenceId), null); } }, null); var disposable2 = bus.SubscribeAndReply <ExclusiveAcceptedRequestMessage <TMessageRequest> >(async message => { return(new ExclusiveAcceptedResponseMessage <TMessageResponse>(await func(message.Request))); }, requestReferenceId); return(new CompositeDisposable(disposable1, disposable2)); }