Exemple #1
0
        public async Task DeleteTopicSubscription(SubscriptionDescription description)
        {
            try
            {
                if (await RootNamespaceManager.SubscriptionExistsAsync(description.TopicPath, description.Name).ConfigureAwait(false))
                {
                    await RootNamespaceManager.DeleteSubscriptionAsync(description.TopicPath, description.Name).ConfigureAwait(false);
                }
            }
            catch (MessagingEntityNotFoundException)
            {
            }

            if (_log.IsDebugEnabled)
            {
                _log.DebugFormat("Subscription Deleted: {0} ({1} -> {2})", description.Name, description.TopicPath, description.ForwardTo);
            }
        }
Exemple #2
0
        public async Task <SubscriptionDescription> CreateTopicSubscription(SubscriptionDescription description)
        {
            var create = true;
            SubscriptionDescription subscriptionDescription = null;

            try
            {
                if (await RootNamespaceManager.SubscriptionExistsAsync(description.TopicPath, description.Name).ConfigureAwait(false))
                {
                    subscriptionDescription = await RootNamespaceManager.GetSubscriptionAsync(description.TopicPath, description.Name).ConfigureAwait(false);

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

                            await RootNamespaceManager.DeleteSubscriptionAsync(description.TopicPath, description.Name).ConfigureAwait(false);
                        }
                    }
                    else
                    {
                        if (description.ForwardTo.Equals(subscriptionDescription.ForwardTo))
                        {
                            if (_log.IsDebugEnabled)
                            {
                                _log.DebugFormat("Updating subscription: {0} ({1} -> {2})", subscriptionDescription.Name, subscriptionDescription.TopicPath,
                                                 subscriptionDescription.ForwardTo);
                            }

                            await RootNamespaceManager.UpdateSubscriptionAsync(description).ConfigureAwait(false);

                            create = false;
                        }
                        else
                        {
                            if (_log.IsWarnEnabled)
                            {
                                _log.WarnFormat("Removing invalid subscription: {0} ({1} -> {2})", subscriptionDescription.Name,
                                                subscriptionDescription.TopicPath,
                                                subscriptionDescription.ForwardTo);
                            }

                            await RootNamespaceManager.DeleteSubscriptionAsync(description.TopicPath, description.Name).ConfigureAwait(false);
                        }
                    }
                }
            }
            catch (MessagingEntityNotFoundException)
            {
            }

            if (create)
            {
                var created = false;
                try
                {
                    if (_log.IsDebugEnabled)
                    {
                        _log.DebugFormat("Creating subscription {0} -> {1}", description.TopicPath, description.ForwardTo);
                    }


                    subscriptionDescription = await RootNamespaceManager.CreateSubscriptionAsync(description).ConfigureAwait(false);

                    created = true;
                }
                catch (MessagingEntityAlreadyExistsException)
                {
                }
                catch (MessagingException mex)
                {
                    if (mex.Message.Contains("(409)"))
                    {
                    }
                    else
                    {
                        throw;
                    }
                }

                if (!created)
                {
                    subscriptionDescription = await RootNamespaceManager.GetSubscriptionAsync(description.TopicPath, description.Name).ConfigureAwait(false);
                }
            }

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

            return(subscriptionDescription);
        }
Exemple #3
0
        public async Task <TopicDescription> CreateTopic(TopicDescription topicDescription)
        {
            var create = true;

            try
            {
                if (await RootNamespaceManager.TopicExistsAsync(topicDescription.Path).ConfigureAwait(false))
                {
                    topicDescription = await RootNamespaceManager.GetTopicAsync(topicDescription.Path).ConfigureAwait(false);

                    create = false;
                }
            }
            catch (MessagingEntityNotFoundException)
            {
            }

            if (create)
            {
                var created = false;
                try
                {
                    if (_log.IsDebugEnabled)
                    {
                        _log.DebugFormat("Creating topic {0}", topicDescription.Path);
                    }

                    topicDescription = await RootNamespaceManager.CreateTopicAsync(topicDescription).ConfigureAwait(false);

                    created = true;
                }
                catch (MessagingEntityAlreadyExistsException)
                {
                }
                catch (MessagingException mex)
                {
                    if (mex.Message.Contains("(409)"))
                    {
                    }
                    else
                    {
                        throw;
                    }
                }

                if (!created)
                {
                    topicDescription = await RootNamespaceManager.GetTopicAsync(topicDescription.Path).ConfigureAwait(false);
                }
            }

            if (_log.IsDebugEnabled)
            {
                _log.DebugFormat("Topic: {0} ({1})", topicDescription.Path,
                                 string.Join(", ", new[]
                {
                    topicDescription.EnableExpress ? "express" : "",
                    topicDescription.RequiresDuplicateDetection ? "dupe detect" : ""
                }.Where(x => !string.IsNullOrWhiteSpace(x))));
            }

            return(topicDescription);
        }