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