Beispiel #1
0
 public Task Deliver(DeliveryContext <InMemoryTransportMessage> context)
 {
     return(context.WasAlreadyDelivered(this)
         ? Task.CompletedTask
         : context.Message.Delay > TimeSpan.Zero
             ? DeliverWithDelay(context)
             : _executor.Push(() => DispatchMessage(context), context.CancellationToken));
 }
Beispiel #2
0
        public async Task Deliver(DeliveryContext <GrpcTransportMessage> context, string routingKey)
        {
            if (_children.TryGetValue("#", out var hashNode))
            {
                await hashNode.Deliver(context, default).ConfigureAwait(false);
            }

            if (string.IsNullOrWhiteSpace(routingKey))
            {
                await _sinks.ForEachAsync(async sink =>
                {
                    if (context.WasAlreadyDelivered(sink))
                    {
                        return;
                    }

                    await sink.Deliver(context).ConfigureAwait(false);

                    context.Delivered(sink);
                }).ConfigureAwait(false);
            }
            else
            {
                var separator = routingKey.IndexOf('.');
                if (separator < 0)
                {
                    if (_children.TryGetValue("*", out var starNode))
                    {
                        await starNode.Deliver(context, default).ConfigureAwait(false);
                    }

                    if (_children.TryGetValue(routingKey, out var childNode))
                    {
                        await childNode.Deliver(context, default).ConfigureAwait(false);
                    }
                }
                else
                {
                    var word = routingKey.Substring(0, separator);

                    var remaining = routingKey.Substring(separator + 1);

                    if (_children.TryGetValue("*", out var starNode))
                    {
                        await starNode.Deliver(context, remaining).ConfigureAwait(false);
                    }

                    if (_children.TryGetValue(word, out var childNode))
                    {
                        await childNode.Deliver(context, remaining).ConfigureAwait(false);
                    }
                }
            }
        }
Beispiel #3
0
        public Task Deliver(DeliveryContext <InMemoryTransportMessage> context)
        {
            if (context.WasAlreadyDelivered(this))
            {
                return(Task.FromResult(false));
            }

            Interlocked.Increment(ref _queueDepth);

            Task.Factory.StartNew(() => DispatchMessage(context.Package), _cancellationToken.Token, TaskCreationOptions.None, _scheduler);

            return(Task.FromResult(true));
        }
        public async Task Deliver(DeliveryContext <GrpcTransportMessage> context)
        {
            await _sinks.ForEachAsync(async sink =>
            {
                if (context.WasAlreadyDelivered(sink))
                {
                    return;
                }

                await sink.Deliver(context).ConfigureAwait(false);

                context.Delivered(sink);
            }).ConfigureAwait(false);
        }
Beispiel #5
0
        public async Task Deliver(DeliveryContext <InMemoryTransportMessage> context)
        {
            foreach (IMessageSink <InMemoryTransportMessage> sink in _sinks)
            {
                if (context.WasAlreadyDelivered(sink))
                {
                    continue;
                }

                await sink.Deliver(context).ConfigureAwait(false);

                context.Delivered(sink);
            }
        }
        public async Task Deliver(DeliveryContext <GrpcTransportMessage> context)
        {
            if (_sinks.TryGetValue(context.Message.RoutingKey ?? "", out Connectable <IMessageSink <GrpcTransportMessage> > forKey))
            {
                await forKey.ForEachAsync(async sink =>
                {
                    if (context.WasAlreadyDelivered(sink))
                    {
                        return;
                    }

                    await sink.Deliver(context).ConfigureAwait(false);

                    context.Delivered(sink);
                }).ConfigureAwait(false);
            }
        }
Beispiel #7
0
        public async Task Deliver(DeliveryContext <GrpcTransportMessage> context)
        {
            if (context.WasAlreadyDelivered(this))
            {
                return;
            }

            if (context.Message.EnqueueTime.HasValue)
            {
                DeliverWithDelay(context);
            }
            else
            {
                await _channel.Writer.WriteAsync(context, context.CancellationToken).ConfigureAwait(false);

                _metrics.MessageCount.Add();
            }
        }
Beispiel #8
0
 public Task Deliver(DeliveryContext <InMemoryTransportMessage> context)
 {
     return(context.WasAlreadyDelivered(this)
         ? Task.FromResult(false)
         : _executor.Push(() => DispatchMessage(context), context.CancellationToken));
 }