Beispiel #1
0
        public SendSettings GetSendSettings(Uri address)
        {
            var name = address.AbsolutePath.Substring(1);

            string[] pathSegments = name.Split('/');
            if (pathSegments.Length == 2)
            {
                name = pathSegments[1];
            }

            if (name == "*")
            {
                throw new ArgumentException("Cannot send to a dynamic address");
            }

            EntityNameValidator.ThrowIfInvalidEntityName(name);

            var isTemporary = address.Query.GetValueFromQueryString("temporary", false);

            var durable    = address.Query.GetValueFromQueryString("durable", !isTemporary);
            var autoDelete = address.Query.GetValueFromQueryString("autodelete", isTemporary);

            var exchangeType = address.Query.GetValueFromQueryString("type") ?? ExchangeTypeSelector.DefaultExchangeType;

            var settings = new RabbitMqSendSettings(name, exchangeType, durable, autoDelete);

            var bindToQueue = address.Query.GetValueFromQueryString("bind", false);

            if (bindToQueue)
            {
                var queueName = WebUtility.UrlDecode(address.Query.GetValueFromQueryString("queue"));
                settings.BindToQueue(queueName);
            }

            var delayedType = address.Query.GetValueFromQueryString("delayedType");

            if (!string.IsNullOrWhiteSpace(delayedType))
            {
                settings.SetExchangeArgument("x-delayed-type", delayedType);
            }

            var bindExchange = address.Query.GetValueFromQueryString("bindexchange");

            if (!string.IsNullOrWhiteSpace(bindExchange))
            {
                settings.BindToExchange(bindExchange);
            }

            var alternateExchange = address.Query.GetValueFromQueryString("alternateexchange");

            if (!string.IsNullOrWhiteSpace(alternateExchange))
            {
                settings.SetExchangeArgument("alternate-exchange", alternateExchange);
            }

            return(settings);
        }
Beispiel #2
0
        /// <summary>
        /// Return the send settings for the address
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static SendSettings GetSendSettings(this Uri address)
        {
            if (string.Compare("rabbitmq", address.Scheme, StringComparison.OrdinalIgnoreCase) != 0)
            {
                throw new RabbitMqAddressException("The invalid scheme was specified: " + address.Scheme);
            }

            string name = address.AbsolutePath.Substring(1);

            string[] pathSegments = name.Split('/');
            if (pathSegments.Length == 2)
            {
                name = pathSegments[1];
            }


            if (name == "*")
            {
                throw new ArgumentException("Cannot send to a dynamic address");
            }

            VerifyQueueOrExchangeNameIsLegal(name);

            bool isTemporary = address.Query.GetValueFromQueryString("temporary", false);

            bool durable    = address.Query.GetValueFromQueryString("durable", !isTemporary);
            bool autoDelete = address.Query.GetValueFromQueryString("autodelete", isTemporary);

            string exchangeType = address.Query.GetValueFromQueryString("type") ?? ExchangeType.Fanout;

            var settings = new RabbitMqSendSettings(name, exchangeType, durable, autoDelete);

            bool bindToQueue = address.Query.GetValueFromQueryString("bind", false);

            if (bindToQueue)
            {
                string queueName = WebUtility.UrlDecode(address.Query.GetValueFromQueryString("queue"));
                settings.BindToQueue(queueName);
            }

            string delayedType = address.Query.GetValueFromQueryString("delayedType");

            if (!string.IsNullOrWhiteSpace(delayedType))
            {
                settings.SetExchangeArgument("x-delayed-type", delayedType);
            }

            string bindExchange = address.Query.GetValueFromQueryString("bindexchange");

            if (!string.IsNullOrWhiteSpace(bindExchange))
            {
                settings.BindToExchange(bindExchange);
            }

            return(settings);
        }
        Uri GetDelayExchangeAddress(ReceiveSettings receiveSettings)
        {
            string delayExchangeName = receiveSettings.QueueName + "_delay";
            var    sendSettings      = new RabbitMqSendSettings(delayExchangeName, "x-delayed-message", receiveSettings.Durable, receiveSettings.AutoDelete);

            sendSettings.SetExchangeArgument("x-delayed-type", receiveSettings.ExchangeType);

            sendSettings.BindToQueue(receiveSettings.QueueName);

            var modelContext = _context.ReceiveContext.GetPayload <ModelContext>();

            return(modelContext.ConnectionContext.HostSettings.GetSendAddress(sendSettings));
        }
Beispiel #4
0
        Task <ISendEndpoint> GetSchedulerEndpoint(Uri destinationAddress)
        {
            var destinationSettings = _topology.GetSendSettings(destinationAddress);

            var sendSettings = new RabbitMqSendSettings(destinationSettings.ExchangeName + "_delay", "x-delayed-message", destinationSettings.Durable,
                                                        destinationSettings.AutoDelete);

            sendSettings.SetExchangeArgument("x-delayed-type", destinationSettings.ExchangeType);

            sendSettings.BindToExchange(destinationSettings.ExchangeName);

            var delayExchangeAddress = sendSettings.GetSendAddress(_hostAddress);

            return(_sendEndpointProvider.GetSendEndpoint(delayExchangeAddress));
        }
        async Task MessageRedeliveryContext.ScheduleRedelivery(TimeSpan delay)
        {
            var receiveSettings = _context.ReceiveContext.GetPayload <ReceiveSettings>();

            string delayExchangeName = receiveSettings.QueueName + "_delay";
            var    sendSettings      = new RabbitMqSendSettings(delayExchangeName, "x-delayed-message", receiveSettings.Durable, receiveSettings.AutoDelete);

            sendSettings.SetExchangeArgument("x-delayed-type", receiveSettings.ExchangeType);

            sendSettings.BindToQueue(receiveSettings.QueueName);

            var modelContext = _context.ReceiveContext.GetPayload <ModelContext>();

            Uri delayExchangeAddress = modelContext.ConnectionContext.HostSettings.GetSendAddress(sendSettings);

            ISendEndpoint delayEndpoint = await _context.GetSendEndpoint(delayExchangeAddress);

            await delayEndpoint.Send(_context.Message, _context.CreateCopyContextPipe((x, y) => UpdateDeliveryContext(x, y, delay)));
        }
Beispiel #6
0
        async Task <ScheduledMessage <T> > ScheduleSend <T>(Uri destinationAddress, DateTime scheduledTime, T message, IPipe <SendContext <T> > pipe, CancellationToken cancellationToken)
            where T : class
        {
            var destinationSettings = _topology.GetSendSettings(destinationAddress);

            var sendSettings = new RabbitMqSendSettings(destinationSettings.ExchangeName + "_delay", "x-delayed-message", destinationSettings.Durable,
                                                        destinationSettings.AutoDelete);

            sendSettings.SetExchangeArgument("x-delayed-type", destinationSettings.ExchangeType);

            sendSettings.BindToExchange(destinationSettings.ExchangeName);

            var delayExchangeAddress = sendSettings.GetSendAddress(_hostAddress);

            var delayEndpoint = await _sendEndpointProvider.GetSendEndpoint(delayExchangeAddress).ConfigureAwait(false);

            var messageId = NewId.NextGuid();

            IPipe <SendContext <T> > delayPipe = Pipe.ExecuteAsync <SendContext <T> >(async context =>
            {
                context.MessageId     = messageId;
                var rabbitSendContext = context.GetPayload <RabbitMqSendContext>();

                var delay = Math.Max(0,
                                     (scheduledTime.Kind == DateTimeKind.Local ? (scheduledTime - DateTime.Now) : (scheduledTime - DateTime.UtcNow)).TotalMilliseconds);

                if (delay > 0)
                {
                    rabbitSendContext.SetTransportHeader("x-delay", (long)delay);
                }

                await pipe.Send(context).ConfigureAwait(false);
            });

            await delayEndpoint.Send(message, delayPipe, cancellationToken).ConfigureAwait(false);

            return(new ScheduledMessageHandle <T>(messageId, scheduledTime, destinationAddress, message));
        }
        /// <summary>
        /// Return the send settings for the address
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        public static SendSettings GetSendSettings(this Uri address)
        {
            if (string.Compare("rabbitmq", address.Scheme, StringComparison.OrdinalIgnoreCase) != 0)
                throw new RabbitMqAddressException("The invalid scheme was specified: " + address.Scheme);

            string name = address.AbsolutePath.Substring(1);
            string[] pathSegments = name.Split('/');
            if (pathSegments.Length == 2)
                name = pathSegments[1];


            if (name == "*")
                throw new ArgumentException("Cannot send to a dynamic address");

            VerifyQueueOrExchangeNameIsLegal(name);

            bool isTemporary = address.Query.GetValueFromQueryString("temporary", false);

            bool durable = address.Query.GetValueFromQueryString("durable", !isTemporary);
            bool autoDelete = address.Query.GetValueFromQueryString("autodelete", isTemporary);

            string exchangeType = address.Query.GetValueFromQueryString("type") ?? ExchangeType.Fanout;

            var settings = new RabbitMqSendSettings(name, exchangeType, durable, autoDelete);

            bool bindToQueue = address.Query.GetValueFromQueryString("bind", false);
            if (bindToQueue)
            {
                string queueName = WebUtility.UrlDecode(address.Query.GetValueFromQueryString("queue"));
                settings.BindToQueue(queueName);
            }

            string delayedType = address.Query.GetValueFromQueryString("delayedType");
            if (!string.IsNullOrWhiteSpace(delayedType))
                settings.SetExchangeArgument("x-delayed-type", delayedType);

            string bindExchange = address.Query.GetValueFromQueryString("bindexchange");
            if (!string.IsNullOrWhiteSpace(bindExchange))
                settings.BindToExchange(bindExchange);

            return settings;
        }