public async Task <byte[]> GetAsync(string key, CancellationToken token = new CancellationToken())
{
if (!_completionSources.TryGetValue(key, out TaskCompletionSource <byte[]> taskCompletionSource))
{
taskCompletionSource = new TaskCompletionSource <byte[]>();
if (!_completionSources.TryAdd(key, taskCompletionSource))
{
return(await GetAsync(key, token).ConfigureAwait(false));
}
}
_publishSubscribe.Publish(_getTopic, new CacheRequest
{
Key = key,
TopicResponse = _selfTopic
}.ToByteArray());
if (token.CanBeCanceled)
{
await Task.WhenAny(
taskCompletionSource.Task,
Task.FromCanceled <object>(token)).ConfigureAwait(false);
_completionSources.TryRemove(key, out var _);
token.ThrowIfCancellationRequested();
}
else
{
await taskCompletionSource.Task.ConfigureAwait(false);
_completionSources.TryRemove(key, out var _);
}
return(taskCompletionSource.Task.Result);
}
public void Event <TMessage>(IWampFormatter <TMessage> formatter, long publicationId, PublishOptions options)
{
if (_disableInternalPublishAtomicBoolean.Value)
{
return;
}
_publishSubscribe.Publish(_forwarderPubSubTopic, new ForwardedWampMessage
{
PublisherId = _publisherId,
WampTopic = _wampTopic.TopicUri
});
}
public Task QueueMessageBatchAsync <T>(Guid streamGuid,
string streamNamespace,
IEnumerable <T> events,
StreamSequenceToken token,
Dictionary <string, object> requestContext)
{
if (_publishSubscribe == null)
{
return(Task.CompletedTask);
}
QueueId queueId = _streamQueueMapper.GetQueueForStream(streamGuid, streamNamespace);
string queueidString = queueId.ToString();
foreach (T @event in events)
{
MessageData messageData = new MessageData(_serializationManager)
{
Payload = _serializationManager.SerializeToByteArray(@event),
StreamGuid = streamGuid,
StreamNamespace = streamNamespace,
SequenceNumber = DateTime.UtcNow.Ticks,
RequestContext = requestContext
};
_publishSubscribe.Publish(queueidString, messageData);
}
return(Task.CompletedTask);
}
public PublishSubscribeDistributedCache(string cacheGroup,
IPublishSubscribe publishSubscribe)
{
_publishSubscribe = publishSubscribe ?? throw new ArgumentNullException(nameof(publishSubscribe));
MemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions
{
CompactionPercentage = 0.1
});
_getTopic = cacheGroup + "_get";
_setTopic = cacheGroup + "_set";
_removeTopic = cacheGroup + "_remove";
publishSubscribe
.Observe <byte[]>(_setTopic)
.Subscribe(_ =>
{
CacheEntry cacheEntry = CacheEntry.Parser.ParseFrom(_.Data);
memoryCache.Set(cacheEntry.Key, cacheEntry);
}, CancellationToken);
publishSubscribe
.Observe <string>(_removeTopic)
.Subscribe(_ => { memoryCache.Remove(_.Data); }, CancellationToken);
publishSubscribe
.Observe <byte[]>(_getTopic)
.Subscribe(_ =>
{
CacheRequest cacheRequest = CacheRequest.Parser.ParseFrom(_.Data);
CacheEntry value = memoryCache.Get <CacheEntry>(cacheRequest.Key) ?? new CacheEntry
{
Key = cacheRequest.Key
};
publishSubscribe.Publish(cacheRequest.TopicResponse, value.ToByteArray());
}, CancellationToken);
_selfTopic = Guid.NewGuid().ToString();
publishSubscribe
.Observe <byte[]>(_selfTopic)
.Subscribe(_ =>
{
CacheEntry cacheEntry = CacheEntry.Parser.ParseFrom(_.Data);
if (_completionSources.TryRemove(cacheEntry.Key, out TaskCompletionSource <byte[]> taskCompletionSource))
{
taskCompletionSource.TrySetResult(cacheEntry.Value.ToByteArray());
}
}, CancellationToken);
}
static void Main(string[] args)
{
IPublishSubscribe bus = BasicContainer.IOC.Resolve <IPublishSubscribe>();
ProjectionOrSomething projection = new ProjectionOrSomething();
UserService userService = new UserService();
//bus.RegisterHandler<EventSending>(projection.Handle);
//bus.RegisterHandler<Event2>(projection.Handle);
//
//bus.RegisterHandler<RegisterUser>(userService.Handle);
bus.Connect();
Console.WriteLine("How many ms per message: ");
int delay = int.Parse(Console.ReadLine());
Console.WriteLine("How many kilobytes per message: ");
int kbs = int.Parse(Console.ReadLine());
Console.WriteLine("Started.");
EventSending s = new EventSending();
for (int i = 0; i < 10 * kbs; i++)
{
s.big.Add(s.bytes_100);
}
Console.WriteLine("Build message. Total Megabytes: " + ((s.big.Count * 100) / (1000 * 1000)).ToString() + "Megabyte");
while (true)
{
bus.Publish(s);
Thread.Sleep(delay);
}
}
public void Raise(IEvent @event)
{
_bus.Publish(@event);
}
public override Task InvokeAllAsync(string methodName, object[] args)
{
_publishSubscribe.Publish(_invokeAllAsyncTopic, (methodName, args));
return(Task.CompletedTask);
}
private Task OnNextAsync(string s, StreamSequenceToken streamSequenceToken)
{
_publishSubscribe.Publish("OnNextAsync", s);
return(Task.CompletedTask);
}
private void PublishMessage(BackplaneMessage message)
{
byte[] serializedMessage = BackplaneMessage.Serialize(message);
_publishSubscribe.Publish(_channelName, serializedMessage);
}
