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