Пример #1
0
        public async Task DeleteTopicSubscription(SubscriptionDescription description)
        {
            try
            {
                await _namespaceManager.DeleteSubscriptionAsync(description.TopicPath, description.SubscriptionName).ConfigureAwait(false);
            }
            catch (MessagingEntityNotFoundException)
            {
            }

            LogContext.Debug?.Log("Subscription Deleted: {Subscription} ({Topic} -> {ForwardTo})", description.SubscriptionName, description.TopicPath,
                                  description.ForwardTo);
        }
        public async Task DeleteTopicSubscription(SubscriptionDescription description)
        {
            try
            {
                await _namespaceManager.DeleteSubscriptionAsync(description.TopicPath, description.SubscriptionName).ConfigureAwait(false);
            }
            catch (MessagingEntityNotFoundException)
            {
            }

            if (_log.IsDebugEnabled)
            {
                _log.DebugFormat("Subscription Deleted: {0} ({1} -> {2})", description.SubscriptionName, description.TopicPath, description.ForwardTo);
            }
        }
Пример #3
0
        public async Task <SubscriptionDescription> CreateTopicSubscription(SubscriptionDescription description, RuleDescription rule, Filter filter)
        {
            var subscriptionExists = await _namespaceManager.SubscriptionExistsAsync(description.TopicPath, description.SubscriptionName).ConfigureAwait(false);

            SubscriptionDescription subscriptionDescription = null;

            if (subscriptionExists)
            {
                subscriptionDescription = await _namespaceManager.GetSubscriptionAsync(description.TopicPath, description.SubscriptionName).ConfigureAwait(false);

                if (string.IsNullOrWhiteSpace(description.ForwardTo))
                {
                    if (!string.IsNullOrWhiteSpace(subscriptionDescription.ForwardTo))
                    {
                        if (_log.IsWarnEnabled)
                        {
                            _log.WarnFormat("Removing invalid subscription: {0} ({1} -> {2})", subscriptionDescription.SubscriptionName,
                                            subscriptionDescription.TopicPath,
                                            subscriptionDescription.ForwardTo);
                        }

                        await _namespaceManager.DeleteSubscriptionAsync(description.TopicPath, description.SubscriptionName).ConfigureAwait(false);
                    }
                }
                else
                {
                    var forwardTo = subscriptionDescription.ForwardTo;
                    var address   = _namespaceManager.Address.ToString();
                    if (forwardTo.StartsWith(address))
                    {
                        forwardTo = forwardTo.Substring(address.Length).Trim('/');
                    }

                    if (description.ForwardTo.Equals(forwardTo))
                    {
                        if (_log.IsDebugEnabled)
                        {
                            _log.DebugFormat("Updating subscription: {0} ({1} -> {2})", subscriptionDescription.SubscriptionName, subscriptionDescription.TopicPath,
                                             subscriptionDescription.ForwardTo);
                        }

                        await _namespaceManager.UpdateSubscriptionAsync(description).ConfigureAwait(false);
                    }
                    else
                    {
                        if (_log.IsWarnEnabled)
                        {
                            _log.WarnFormat("Removing invalid subscription: {0} ({1} -> {2})", subscriptionDescription.SubscriptionName,
                                            subscriptionDescription.TopicPath,
                                            subscriptionDescription.ForwardTo);
                        }

                        await _namespaceManager.DeleteSubscriptionAsync(description.TopicPath, description.SubscriptionName).ConfigureAwait(false);
                    }
                }
            }
            else
            {
                try
                {
                    if (_log.IsDebugEnabled)
                    {
                        _log.DebugFormat("Creating subscription {0} -> {1}", description.TopicPath, description.ForwardTo);
                    }

                    subscriptionDescription = rule != null
                        ? await _namespaceManager.CreateSubscriptionAsync(description, rule).ConfigureAwait(false)
                        : filter != null
                            ? await _namespaceManager.CreateSubscriptionAsync(description, filter).ConfigureAwait(false)
                            : await _namespaceManager.CreateSubscriptionAsync(description).ConfigureAwait(false);
                }
                catch (MessagingEntityAlreadyExistsException)
                {
                    subscriptionDescription = await _namespaceManager.GetSubscriptionAsync(description.TopicPath, description.SubscriptionName).ConfigureAwait(false);
                }
            }

            if (_log.IsDebugEnabled)
            {
                _log.DebugFormat("Subscription: {0} ({1} -> {2})", subscriptionDescription.SubscriptionName, subscriptionDescription.TopicPath,
                                 subscriptionDescription.ForwardTo);
            }

            return(subscriptionDescription);
        }