Management Operations

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

@@ -1,6 +1,9 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Xml.Linq;
+using Microsoft.Azure.ServiceBus.Management;
+
 namespace Microsoft.Azure.ServiceBus
 {
     /// <summary>
@@ -24,5 +27,28 @@ internal Filter()
             // This is intentionally left blank. This constructor exists
             // only to prevent external assemblies inheriting from it.
         }
+
+        internal static Filter ParseFromXElement(XElement xElement)
+        {
+            var attribute = xElement.Attribute(XName.Get("type", ManagementConstants.XmlSchemaNs));
+            if (attribute == null)
+            {
+                return null;
+            }
+
+            switch (attribute.Value)
+            {
+                case "SqlFilter":
+                    return SqlFilter.ParseFromXElement(xElement);
+                case "CorrelationFilter":
+                    return CorrelationFilter.ParseFromXElement(xElement);
+                case "TrueFilter":
+                    return new TrueFilter();
+                case "FalseFilter":
+                    return new FalseFilter();
+                default:
+                    return null;
+            }
+        }
     }
 }

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

@@ -1,6 +1,9 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Xml.Linq;
+using Microsoft.Azure.ServiceBus.Management;
+
 namespace Microsoft.Azure.ServiceBus
 {
     /// <summary>
@@ -20,5 +23,24 @@ internal RuleAction()
             // This is intentionally left blank. This constructor exists
             // only to prevent external assemblies inheriting from it.
         }
+
+        internal static RuleAction ParseFromXElement(XElement xElement)
+        {
+            var attribute = xElement.Attribute(XName.Get("type", ManagementConstants.XmlSchemaNs));
+            if (attribute == null)
+            {
+                return null;
+            }
+
+            switch (attribute.Value)
+            {
+                case "SqlRuleAction":
+                    return SqlRuleAction.ParseFromXElement(xElement);
+                case "EmptyRuleAction":
+                    return null;
+                default:
+                    return null;
+            }
+        }
     }
 }

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

@@ -1,6 +1,10 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
+using System.Collections.Generic;
+using System.Xml.Linq;
+using Microsoft.Azure.ServiceBus.Management;
 using Microsoft.Azure.ServiceBus.Primitives;
 
 namespace Microsoft.Azure.ServiceBus
@@ -113,6 +117,12 @@ public string Name
             }
         }
 
+        // TODO: Implement for AMQP
+        public DateTime CreatedAt
+        {
+            get; internal set;
+        }
+
         internal void ValidateDescriptionName()
         {
             if (string.IsNullOrWhiteSpace(this.name))
@@ -146,5 +156,83 @@ internal void ValidateDescriptionName()
                 }
             }
         }
+
+        static internal RuleDescription ParseFromContent(string xml)
+        {
+            var xDoc = XElement.Parse(xml);
+            if (!xDoc.IsEmpty)
+            {
+                if (xDoc.Name.LocalName == "entry")
+                {
+                    return ParseFromEntryElement(xDoc);
+                }
+            }
+
+            throw new MessagingEntityNotFoundException("Rule was not found");
+        }
+
+        static internal IList<RuleDescription> ParseCollectionFromContent(string xml)
+        {
+            var xDoc = XElement.Parse(xml);
+            if (!xDoc.IsEmpty)
+            {
+                if (xDoc.Name.LocalName == "feed")
+                {
+                    var rules = new List<RuleDescription>();
+
+                    var entryList = xDoc.Elements(XName.Get("entry", ManagementConstants.AtomNs));
+                    foreach (var entry in entryList)
+                    {
+                        rules.Add(ParseFromEntryElement(entry));
+                    }
+
+                    return rules;
+                }
+            }
+
+            throw new MessagingEntityNotFoundException("Rule was not found");
+        }
+
+        static private RuleDescription ParseFromEntryElement(XElement xEntry)
+        {
+            try
+            {
+                var name = xEntry.Element(XName.Get("title", ManagementConstants.AtomNs)).Value;
+                var ruleDescription = new RuleDescription();
+
+                var rdXml = xEntry.Element(XName.Get("content", ManagementConstants.AtomNs))?
+                    .Element(XName.Get("RuleDescription", ManagementConstants.SbNs));
+
+                if (rdXml == null)
+                {
+                    throw new MessagingEntityNotFoundException("Rule was not found");
+                }
+
+                foreach (var element in rdXml.Elements())
+                {
+                    switch (element.Name.LocalName)
+                    {
+                        case "Name":
+                            ruleDescription.Name = element.Value;
+                            break;
+                        case "Filter":
+                            ruleDescription.Filter = Filter.ParseFromXElement(element);
+                            break;
+                        case "Action":
+                            ruleDescription.Action = RuleAction.ParseFromXElement(element);
+                            break;
+                        case "CreatedAt":
+                            ruleDescription.CreatedAt = DateTime.Parse(element.Value);
+                            break;
+                    }
+                }
+
+                return ruleDescription;
+            }
+            catch (Exception ex) when (!(ex is ServiceBusException))
+            {
+                throw new ServiceBusException(false, ex);
+            }
+        }
     }
 }

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

@@ -5,6 +5,8 @@ namespace Microsoft.Azure.ServiceBus
 {
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Xml.Linq;
+    using Microsoft.Azure.ServiceBus.Management;
     using Primitives;
 
     /// <summary>
@@ -65,5 +67,18 @@ public override string ToString()
         {
             return string.Format(CultureInfo.InvariantCulture, "SqlFilter: {0}", this.SqlExpression);
         }
+
+        internal new static Filter ParseFromXElement(XElement xElement)
+        {
+            var expression = xElement.Element(XName.Get("SqlExpression", ManagementConstants.SbNs))?.Value;
+            if (string.IsNullOrWhiteSpace(expression))
+            {
+                return null;
+            }
+
+            var filter = new SqlFilter(expression);
+            // TODO: populate parameters
+            return filter;
+        }
     }
 }

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

@@ -5,6 +5,7 @@ namespace Microsoft.Azure.ServiceBus
 {
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Xml.Linq;
     using Primitives;
 
     /// <summary>
@@ -59,5 +60,10 @@ public override string ToString()
         {
             return string.Format(CultureInfo.InvariantCulture, "SqlRuleAction: {0}", this.SqlExpression);
         }
+
+        internal new static RuleAction ParseFromXElement(XElement xElement)
+        {
+            return null;
+        }
     }
 }

src/Microsoft.Azure.ServiceBus/Management/AuthorizationRule.cs

@@ -0,0 +1,8 @@
+namespace Microsoft.Azure.ServiceBus.Management
+{
+    // TODO
+    // Extended by SharedAccessAuthorizationRule
+    public abstract class AuthorizationRule
+    {
+    }
+}

src/Microsoft.Azure.ServiceBus/Management/AuthorizationRules.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Microsoft.Azure.ServiceBus.Management
+{
+    public class AuthorizationRules : List<AuthorizationRule>
+    {
+        public bool RequiresEncryption { get; set; }
+    }
+}

src/Microsoft.Azure.ServiceBus/Management/EntityStatus.cs

@@ -0,0 +1,27 @@
+using System.Runtime.Serialization;
+
+namespace Microsoft.Azure.ServiceBus.Management
+{
+    public enum EntityStatus
+    {
+        /// <summary>The status of the messaging entity is active.</summary>
+        [EnumMember]
+        Active = 0,
+
+        /// <summary>The status of the messaging entity is disabled.</summary>
+        [EnumMember]
+        Disabled = 1,
+
+        /// <summary>The sending status of the messaging entity is disabled.</summary>
+        [EnumMember]
+        SendDisabled = 3,
+
+        /// <summary>The receiving status of the messaging entity is disabled.</summary>
+        [EnumMember]
+        ReceiveDisabled = 4,
+
+        /// <summary>The status of the messaging entity is unknown.</summary>
+        [EnumMember]
+        Unknown = 99
+    }
+}

src/Microsoft.Azure.ServiceBus/Management/IManagementClient.cs

@@ -0,0 +1,72 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Azure.ServiceBus.Management
+{
+    public interface IManagementClient
+    {
+        // Create if not exist. Else throw.
+        Task<QueueDescription> CreateQueueAsync(string queueName, CancellationToken cancellationToken = default);
+
+        Task<QueueDescription> CreateQueueAsync(QueueDescription queueDescription, CancellationToken cancellationToken = default);
+
+        Task<TopicDescription> CreateTopicAsync(string topicName, CancellationToken cancellationToken = default);
+
+        Task<TopicDescription> CreateTopicAsync(TopicDescription topicDescription, CancellationToken cancellationToken = default);
+
+        Task<SubscriptionDescription> CreateSubscriptionAsync(string topicName, string subscriptionName, CancellationToken cancellationToken = default);
+
+        Task<SubscriptionDescription> CreateSubscriptionAsync(SubscriptionDescription subscriptionDescription, CancellationToken cancellationToken = default);
+
+        Task<RuleDescription> CreateRuleAsync(string topicName, string subscriptionName, RuleDescription ruleDescription, CancellationToken cancellationToken = default);
+
+        // Delete
+        Task DeleteQueueAsync(string queueName, CancellationToken cancellationToken = default);
+
+        Task DeleteTopicAsync(string topicName, CancellationToken cancellationToken = default);
+
+        Task DeleteSubscriptionAsync(string topicName, string subscriptionName, CancellationToken cancellationToken = default);
+
+        Task DeleteRuleAsync(string topicName, string subscriptionName, string ruleName, CancellationToken cancellationToken = default);
+
+        // Get entity description
+        Task<QueueDescription> GetQueueAsync(string queueName, CancellationToken cancellationToken = default);
+
+        Task<TopicDescription> GetTopicAsync(string topicName, CancellationToken cancellationToken = default);
+
+        Task<SubscriptionDescription> GetSubscriptionAsync(string topicName, string subscriptionName, CancellationToken cancellationToken = default);
+
+        Task<RuleDescription> GetRuleAsync(string topicName, string subscriptionName, string ruleName, CancellationToken cancellationToken = default);
+
+        // Get entity runtime information
+        Task<QueueRuntimeInfo> GetQueueRuntimeInfoAsync(string queueName, CancellationToken cancellationToken = default);
+
+        Task<TopicRuntimeInfo> GetTopicRuntimeInfoAsync(string topicName, CancellationToken cancellationToken = default);
+
+        Task<SubscriptionRuntimeInfo> GetSubscriptionRuntimeInfoAsync(string topicName, string subscriptionName, CancellationToken cancellationToken = default);
+
+        // Get entities (max of 100 at a time)
+        Task<IList<QueueDescription>> GetQueuesAsync(int count = 100, int skip = 0, CancellationToken cancellationToken = default);
+
+        Task<IList<TopicDescription>> GetTopicsAsync(int count = 100, int skip = 0, CancellationToken cancellationToken = default);
+
+        Task<IList<SubscriptionDescription>> GetSubscriptionsAsync(string topicName, int count = 100, int skip = 0, CancellationToken cancellationToken = default);
+
+        Task<IList<RuleDescription>> GetRulesAsync(string topicName, string subscriptionName, int count = 100, int skip = 0, CancellationToken cancellationToken = default);
+
+        // Update entity if exists. Else throws.
+        Task<QueueDescription> UpdateQueueAsync(QueueDescription queueDescription, CancellationToken cancellationToken = default);
+
+        Task<TopicDescription> UpdateTopicAsync(TopicDescription topicDescription, CancellationToken cancellationToken = default);
+
+        Task<SubscriptionDescription> UpdateSubscriptionAsync(SubscriptionDescription subscriptionDescription, CancellationToken cancellationToken = default);
+
+        // Exists check
+        Task<bool> QueueExistsAsync(string queueName, CancellationToken cancellationToken = default);
+
+        Task<bool> TopicExistsAsync(string topicName, CancellationToken cancellationToken = default);
+
+        Task<bool> SubscriptionExistsAsync(string topicName, string subscriptionName, CancellationToken cancellationToken = default);
+    }
+}