Management Operations

src/Microsoft.Azure.ServiceBus/Amqp/AmqpMessageConverter.cs

@@ -379,10 +379,9 @@ public static RuleDescription GetRuleDescription(AmqpRuleDescriptionCodec amqpDe
             var filter = GetFilter(amqpDescription.Filter);
             var ruleAction = GetRuleAction(amqpDescription.Action);
 
-            var ruleDescription = new RuleDescription(filter)
+            var ruleDescription = new RuleDescription(amqpDescription.RuleName, filter)
             {
-                Action = ruleAction,
-                Name = amqpDescription.RuleName
+                Action = ruleAction
             };
 
             return ruleDescription;

src/Microsoft.Azure.ServiceBus/EntityNameHelper.cs

@@ -3,13 +3,17 @@
 
 namespace Microsoft.Azure.ServiceBus
 {
+    using System;
+    using Microsoft.Azure.ServiceBus.Management;
+
     /// <summary>
     /// This class can be used to format the path for different Service Bus entity types.
     /// </summary>
     public static class EntityNameHelper
     {
         private const string PathDelimiter = @"/";
-        private const string Subscriptions = "Subscriptions";
+        private const string SubscriptionsSubPath = "Subscriptions";
+        private const string RulesSubPath = "Rules";
         private const string SubQueuePrefix = "$";
         private const string DeadLetterQueueSuffix = "DeadLetterQueue";
         private const string DeadLetterQueueName = SubQueuePrefix + DeadLetterQueueSuffix;
@@ -40,9 +44,25 @@ public static string FormatSubQueuePath(string entityPath, string subQueueName)
         /// Formats the subscription path, based on the topic path and subscription name.
         /// </summary>
         /// <param name="topicPath">The name of the topic, including slashes.</param>
+        /// <param name="subscriptionName">The name of the subscription.</param>
         public static string FormatSubscriptionPath(string topicPath, string subscriptionName)
         {
-            return string.Concat(topicPath, PathDelimiter, Subscriptions, PathDelimiter, subscriptionName);
+            return string.Concat(topicPath, PathDelimiter, SubscriptionsSubPath, PathDelimiter, subscriptionName);
+        }
+
+        /// <summary>
+        /// Formats the rule path, based on the topic path and subscription name.
+        /// </summary>
+        /// <param name="topicPath">The name of the topic, including slashes.</param>
+        /// <param name="subscriptionName">The name of the subscription.</param>
+        /// <param name="ruleName">The name of the rule</param>
+        public static string FormatRulePath(string topicPath, string subscriptionName, string ruleName)
+        {
+            return string.Concat(
+                topicPath, PathDelimiter, 
+                SubscriptionsSubPath, PathDelimiter, 
+                subscriptionName, PathDelimiter, 
+                RulesSubPath, PathDelimiter, ruleName);
         }
 
         /// <summary>
@@ -52,5 +72,60 @@ public static string FormatSubscriptionPath(string topicPath, string subscriptio
         {
             return string.Concat(entityPath, PathDelimiter, TransferDeadLetterQueueName);
         }
+
+        internal static void CheckValidQueueName(string queueName, string paramName = "queuePath")
+        {
+            CheckValidEntityName(queueName, ManagementClientConstants.QueueNameMaximumLength, true, paramName);
+        }
+
+        internal static void CheckValidTopicName(string topicName, string paramName = "topicPath")
+        {
+            CheckValidEntityName(topicName, ManagementClientConstants.TopicNameMaximumLength, true, paramName);
+        }
+
+        internal static void CheckValidSubscriptionName(string subscriptionName, string paramName = "subscriptionName")
+        {
+            CheckValidEntityName(subscriptionName, ManagementClientConstants.SubscriptionNameMaximumLength, false, paramName);
+        }
+
+        internal static void CheckValidRuleName(string ruleName, string paramName = "ruleName")
+        {
+            CheckValidEntityName(ruleName, ManagementClientConstants.RuleNameMaximumLength, false, paramName);
+        }
+
+        private static void CheckValidEntityName(string entityName, int maxEntityNameLength, bool allowSeparator, string paramName)
+        {
+            if (string.IsNullOrWhiteSpace(entityName))
+            {
+                throw new ArgumentNullException(paramName);
+            }
+
+            // and "\" will be converted to "/" on the REST path anyway. Gateway/REST do not
+            // have to worry about the begin/end slash problem, so this is purely a client side check.
+            var tmpName = entityName.Replace(@"\", Constants.PathDelimiter);
+            if (tmpName.Length > maxEntityNameLength)
+            {
+                throw new ArgumentOutOfRangeException(paramName, $@"Entity path '{entityName}' exceeds the '{maxEntityNameLength}' character limit.");
+            }
+
+            if (tmpName.StartsWith(Constants.PathDelimiter, StringComparison.OrdinalIgnoreCase) ||
+                tmpName.EndsWith(Constants.PathDelimiter, StringComparison.OrdinalIgnoreCase))
+            {
+                throw new ArgumentException($@"The entity name/path cannot contain '/' as prefix or suffix. The supplied value is '{entityName}'", paramName);
+            }
+
+            if (!allowSeparator && tmpName.Contains(Constants.PathDelimiter))
+            {
+                throw new ArgumentException($@"The entity name/path contains an invalid character '{Constants.PathDelimiter}'", paramName);
+            }
+
+            foreach (var uriSchemeKey in ManagementClientConstants.InvalidEntityPathCharacters)
+            {
+                if (entityName.IndexOf(uriSchemeKey) >= 0)
+                {
+                    throw new ArgumentException($@"'{entityName}' contains character '{uriSchemeKey}' which is not allowed because it is reserved in the Uri scheme.", paramName);
+                }
+            }
+        }
     }
 }

src/Microsoft.Azure.ServiceBus/Filters/CorrelationFilter.cs

@@ -3,6 +3,7 @@
 
 namespace Microsoft.Azure.ServiceBus
 {
+    using System;
     using System.Collections.Generic;
     using System.Text;
     using Primitives;
@@ -29,7 +30,7 @@ namespace Microsoft.Azure.ServiceBus
     /// </remarks>
     public sealed class CorrelationFilter : Filter
     {
-        private PropertyDictionary properties;
+        internal PropertyDictionary properties;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="CorrelationFilter" /> class with default values.
@@ -197,5 +198,84 @@ void AppendPropertyExpression(ref bool firstExpression, StringBuilder builder, s
                 builder.AppendFormat("{0} = '{1}'", propertyName, value);
             }
         }
+
+        public override int GetHashCode()
+        {
+            int hash = 13;
+            unchecked
+            {
+                hash = (hash * 7) + this.CorrelationId?.GetHashCode() ?? 0;
+                hash = (hash * 7) + this.MessageId?.GetHashCode() ?? 0;
+                hash = (hash * 7) + this.SessionId?.GetHashCode() ?? 0; 
+            }
+
+            return hash;
+        }
+
+        public override bool Equals(object obj)
+        {
+            var other = obj as CorrelationFilter;
+            return this.Equals(other);
+        }
+
+        public override bool Equals(Filter other)
+        {
+            if (other is CorrelationFilter correlationFilter)
+            {
+                if (string.Equals(this.CorrelationId, correlationFilter.CorrelationId, StringComparison.OrdinalIgnoreCase)
+                    && string.Equals(this.MessageId, correlationFilter.MessageId, StringComparison.OrdinalIgnoreCase)
+                    && string.Equals(this.To, correlationFilter.To, StringComparison.OrdinalIgnoreCase)
+                    && string.Equals(this.ReplyTo, correlationFilter.ReplyTo, StringComparison.OrdinalIgnoreCase)
+                    && string.Equals(this.Label, correlationFilter.Label, StringComparison.OrdinalIgnoreCase)
+                    && string.Equals(this.SessionId, correlationFilter.SessionId, StringComparison.OrdinalIgnoreCase)
+                    && string.Equals(this.ReplyToSessionId, correlationFilter.ReplyToSessionId, StringComparison.OrdinalIgnoreCase)
+                    && string.Equals(this.ContentType, correlationFilter.ContentType, StringComparison.OrdinalIgnoreCase)
+                    && (this.properties != null && correlationFilter.properties != null
+                        || this.properties == null && correlationFilter.properties == null))
+                {
+                    if (this.properties != null)
+                    {
+                        if (this.properties.Count != correlationFilter.properties.Count)
+                        {
+                            return false;
+                        }
+
+                        foreach (var param in this.properties)
+                        {
+                            if (!correlationFilter.properties.TryGetValue(param.Key, out var otherParamValue) ||
+                                (param.Value == null ^ otherParamValue == null) ||
+                                (param.Value != null && !param.Value.Equals(otherParamValue)))
+                            {
+                                return false;
+                            }
+                        }
+                    }
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static bool operator == (CorrelationFilter o1, CorrelationFilter o2)
+        {
+            if (ReferenceEquals(o1, o2))
+            {
+                return true;
+            }
+
+            if (ReferenceEquals(o1, null) || ReferenceEquals(o2, null))
+            {
+                return false;
+            }
+
+            return o1.Equals(o2);
+        }
+
+        public static bool operator != (CorrelationFilter p1, CorrelationFilter p2)
+        {
+            return !(p1 == p2);
+        }
     }
 }

src/Microsoft.Azure.ServiceBus/Filters/CorrelationFilterExtensions.cs

@@ -0,0 +1,99 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Azure.ServiceBus
+{
+    using System.Xml.Linq;
+    using Microsoft.Azure.ServiceBus.Filters;
+    using Microsoft.Azure.ServiceBus.Management;
+
+    internal static class CorrelationFilterExtensions
+    {
+        public static Filter ParseFromXElement(XElement xElement)
+        {
+            var correlationFilter = new CorrelationFilter();
+            foreach (var element in xElement.Elements())
+            {
+                switch (element.Name.LocalName)
+                {
+                    case "CorrelationId":
+                        correlationFilter.CorrelationId = element.Value;
+                        break;
+                    case "MessageId":
+                        correlationFilter.MessageId = element.Value;
+                        break;
+                    case "To":
+                        correlationFilter.To = element.Value;
+                        break;
+                    case "ReplyTo":
+                        correlationFilter.ReplyTo = element.Value;
+                        break;
+                    case "Label":
+                        correlationFilter.Label = element.Value;
+                        break;
+                    case "SessionId":
+                        correlationFilter.SessionId = element.Value;
+                        break;
+                    case "ReplyToSessionId":
+                        correlationFilter.ReplyToSessionId = element.Value;
+                        break;
+                    case "ContentType":
+                        correlationFilter.ContentType = element.Value;
+                        break;
+                    case "Properties":
+                        foreach (var prop in element.Elements(XName.Get("KeyValueOfstringanyType", ManagementClientConstants.SbNs)))
+                        {
+                            var key = prop.Element(XName.Get("Key", ManagementClientConstants.SbNs))?.Value;
+                            var value = XmlObjectConvertor.ParseValueObject(prop.Element(XName.Get("Value", ManagementClientConstants.SbNs)));
+                            correlationFilter.Properties.Add(key, value);
+                        }
+                        break;
+                    default:
+                        MessagingEventSource.Log.ManagementSerializationException(
+                            $"{nameof(CorrelationFilterExtensions)}_{nameof(ParseFromXElement)}",
+                            element.ToString());
+                        break;
+                }
+            }
+
+            return correlationFilter;
+        }
+
+        public static XElement Serialize(this CorrelationFilter filter)
+        {
+            XElement parameterElement = null;
+            if (filter.properties != null)
+            {
+                parameterElement = new XElement(XName.Get("Properties", ManagementClientConstants.SbNs));
+                foreach (var param in filter.properties)
+                {
+                    parameterElement.Add(
+                        new XElement(XName.Get("KeyValueOfstringanyType", ManagementClientConstants.SbNs),
+                            new XElement(XName.Get("Key", ManagementClientConstants.SbNs), param.Key),
+                            XmlObjectConvertor.SerializeObject(param.Value)));
+                }
+            }
+
+            return new XElement(
+                XName.Get("Filter", ManagementClientConstants.SbNs),
+                new XAttribute(XName.Get("type", ManagementClientConstants.XmlSchemaInstanceNs), nameof(CorrelationFilter)),
+                string.IsNullOrWhiteSpace(filter.CorrelationId) ? null :
+                    new XElement(XName.Get("CorrelationId", ManagementClientConstants.SbNs), filter.CorrelationId),
+                string.IsNullOrWhiteSpace(filter.MessageId) ? null :
+                    new XElement(XName.Get("MessageId", ManagementClientConstants.SbNs), filter.MessageId),
+                string.IsNullOrWhiteSpace(filter.To) ? null :
+                    new XElement(XName.Get("To", ManagementClientConstants.SbNs), filter.To),
+                string.IsNullOrWhiteSpace(filter.ReplyTo) ? null :
+                    new XElement(XName.Get("ReplyTo", ManagementClientConstants.SbNs), filter.ReplyTo),
+                string.IsNullOrWhiteSpace(filter.Label) ? null :
+                    new XElement(XName.Get("Label", ManagementClientConstants.SbNs), filter.Label),
+                string.IsNullOrWhiteSpace(filter.SessionId) ? null :
+                    new XElement(XName.Get("SessionId", ManagementClientConstants.SbNs), filter.SessionId),
+                string.IsNullOrWhiteSpace(filter.ReplyToSessionId) ? null :
+                    new XElement(XName.Get("ReplyToSessionId", ManagementClientConstants.SbNs), filter.ReplyToSessionId),
+                string.IsNullOrWhiteSpace(filter.ContentType) ? null :
+                    new XElement(XName.Get("ContentType", ManagementClientConstants.SbNs), filter.ContentType),
+                parameterElement);
+        }
+    }
+}

src/Microsoft.Azure.ServiceBus/Filters/FalseFilter.cs

@@ -8,8 +8,6 @@ namespace Microsoft.Azure.ServiceBus
     /// </summary>
     public sealed class FalseFilter : SqlFilter
     {
-        internal static readonly FalseFilter Default = new FalseFilter();
-
         /// <summary>
         /// Initializes a new instance of the <see cref="FalseFilter" /> class.
         /// </summary>
@@ -26,5 +24,40 @@ public override string ToString()
         {
             return "FalseFilter";
         }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is FalseFilter;
+        }
+
+        public override bool Equals(Filter other)
+        {
+            return other is FalseFilter;
+        }
+
+        public static bool operator ==(FalseFilter o1, FalseFilter o2)
+        {
+            if (ReferenceEquals(o1, o2))
+            {
+                return true;
+            }
+
+            if (ReferenceEquals(o1, null) || ReferenceEquals(o2, null))
+            {
+                return false;
+            }
+
+            return o1.Equals(o2);
+        }
+
+        public static bool operator !=(FalseFilter o1, FalseFilter o2)
+        {
+            return !(o1 == o2);
+        }
     }
 }