Add support for Cloud Load Balancers (fixes #217)

Author: sharwell

src/corelib/Providers/Rackspace/CloudLoadBalancerProvider.cs

@@ -0,0 +1,89 @@
+namespace net.openstack.Providers.Rackspace.Objects.LoadBalancers
+{
+    using System;
+    using System.Collections.Concurrent;
+    using net.openstack.Core;
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// Represents an network access type in the load balancers service.
+    /// </summary>
+    /// <remarks>
+    /// This class functions as a strongly-typed enumeration of known access types,
+    /// with added support for unknown types returned by a server extension.
+    /// </remarks>
+    /// <seealso href="http://docs.rackspace.com/loadbalancers/api/v1.0/clb-devguide/content/Manage_Access_Lists-d1e3187.html">Manage Access Lists (Rackspace Cloud Load Balancers Developer Guide - API v1.0)</seealso>
+    /// <threadsafety static="true" instance="false"/>
+    /// <preliminary/>
+    [JsonConverter(typeof(AccessType.Converter))]
+    public sealed class AccessType : ExtensibleEnum<AccessType>
+    {
+        private static readonly ConcurrentDictionary<string, AccessType> _types =
+            new ConcurrentDictionary<string, AccessType>(StringComparer.OrdinalIgnoreCase);
+        private static readonly AccessType _allow = FromName("ALLOW");
+        private static readonly AccessType _deny = FromName("DENY");
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AccessType"/> class with the specified name.
+        /// </summary>
+        /// <inheritdoc/>
+        private AccessType(string name)
+            : base(name)
+        {
+        }
+
+        /// <summary>
+        /// Gets the <see cref="AccessType"/> instance with the specified name.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <exception cref="ArgumentNullException">If <paramref name="name"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentException">If <paramref name="name"/> is empty.</exception>
+        public static AccessType FromName(string name)
+        {
+            if (name == null)
+                throw new ArgumentNullException("name");
+            if (string.IsNullOrEmpty(name))
+                throw new ArgumentException("name cannot be empty");
+
+            return _types.GetOrAdd(name, i => new AccessType(i));
+        }
+
+        /// <summary>
+        /// Gets an <see cref="AccessType"/> representing an item to which traffic should be allowed.
+        /// The <see cref="Allow"/> access type takes priority over the <see cref="Deny"/> access type.
+        /// </summary>
+        public static AccessType Allow
+        {
+            get
+            {
+                return _allow;
+            }
+        }
+
+        /// <summary>
+        /// Gets an <see cref="AccessType"/> representing an item to which traffic can be denied.
+        /// </summary>
+        public static AccessType Deny
+        {
+            get
+            {
+                return _deny;
+            }
+        }
+
+        /// <summary>
+        /// Provides support for serializing and deserializing <see cref="AccessType"/>
+        /// objects to JSON string values.
+        /// </summary>
+        /// <threadsafety static="true" instance="false"/>
+        /// <preliminary/>
+        private sealed class Converter : ConverterBase
+        {
+            /// <inheritdoc/>
+            protected override AccessType FromName(string name)
+            {
+                return AccessType.FromName(name);
+            }
+        }
+    }
+}

src/corelib/Providers/Rackspace/ILoadBalancerService.cs

@@ -0,0 +1,43 @@
+namespace net.openstack.Providers.Rackspace.Objects.LoadBalancers
+{
+    using System;
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// This class models the JSON object used to represent a <see cref="HealthMonitor"/> for
+    /// simple connection monitoring.
+    /// </summary>
+    /// <threadsafety static="true" instance="false"/>
+    /// <preliminary/>
+    [JsonObject(MemberSerialization.OptIn)]
+    public class ConnectionHealthMonitor : HealthMonitor
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConnectionHealthMonitor"/> class
+        /// during JSON deserialization.
+        /// </summary>
+        [JsonConstructor]
+        protected ConnectionHealthMonitor()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConnectionHealthMonitor"/> class
+        /// with the specified values.
+        /// </summary>
+        /// <param name="attemptsBeforeDeactivation">The number of permissible monitor failures before removing a node from rotation.</param>
+        /// <param name="timeout">The maximum number of seconds to wait for a connection to be established before timing out.</param>
+        /// <param name="delay">The minimum time to wait before executing the health monitor.</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// If <paramref name="attemptsBeforeDeactivation"/> is less than or equal to 0.
+        /// <para>-or-</para>
+        /// <para>If <paramref name="timeout"/> is negative or <see cref="TimeSpan.Zero"/>.</para>
+        /// <para>-or-</para>
+        /// <para>If <paramref name="delay"/> is negative or <see cref="TimeSpan.Zero"/>.</para>
+        /// </exception>
+        public ConnectionHealthMonitor(int attemptsBeforeDeactivation, TimeSpan timeout, TimeSpan delay)
+            : base(HealthMonitorType.Connect, attemptsBeforeDeactivation, timeout, delay)
+        {
+        }
+    }
+}

src/corelib/Providers/Rackspace/Objects/LoadBalancers/AccessType.cs

@@ -0,0 +1,145 @@
+namespace net.openstack.Providers.Rackspace.Objects.LoadBalancers
+{
+    using System;
+    using Newtonsoft.Json;
+
+    /// <summary>
+    /// This class represents a connection throttling configuration for a load
+    /// balancer in the load balancer service.
+    /// </summary>
+    /// <threadsafety static="true" instance="false"/>
+    /// <preliminary/>
+    [JsonObject(MemberSerialization.OptIn)]
+    public class ConnectionThrottles
+    {
+        /// <summary>
+        /// This is the backing field for the <see cref="MaxConnectionRate"/> property.
+        /// </summary>
+        [JsonProperty("maxConnectionRate", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        private int? _maxConnectionRate;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="MaxConnections"/> property.
+        /// </summary>
+        [JsonProperty("maxConnections", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        private int? _maxConnections;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="MinConnections"/> property.
+        /// </summary>
+        [JsonProperty("minConnections", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        private int? _minConnections;
+
+        /// <summary>
+        /// This is the backing field for the <see cref="RateInterval"/> property.
+        /// </summary>
+        [JsonProperty("rateInterval", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        private int? _rateInterval;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConnectionThrottles"/> class during
+        /// JSON deserialization.
+        /// </summary>
+        [JsonConstructor]
+        protected ConnectionThrottles()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConnectionThrottles"/> class with
+        /// the specified configuration.
+        /// </summary>
+        /// <param name="maxConnectionRate">The maximum number of connections per rate interval to allow from a single IP address, or <c>0</c> to not limit the connection rate. If this value is <c>null</c>, the value for this throttle will not be changed during a call to <see cref="ILoadBalancerService.UpdateThrottlesAsync"/>.</param>
+        /// <param name="maxConnections">The maximum number of connections to allow from a single IP address, or <c>0</c> to not limit the number connections. If this value is <c>null</c>, the value for this throttle will not be changed during a call to <see cref="ILoadBalancerService.UpdateThrottlesAsync"/>.</param>
+        /// <param name="minConnections">The minimum number of connections to allow from an IP address before applying throttling restrictions. If this value is <c>null</c>, the value for this throttle will not be changed during a call to <see cref="ILoadBalancerService.UpdateThrottlesAsync"/>.</param>
+        /// <param name="rateInterval">The time period for which the connection rate limit is evaluated. If this value is <c>null</c>, the value for this throttle will not be changed during a call to <see cref="ILoadBalancerService.UpdateThrottlesAsync"/>.</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// If <paramref name="maxConnectionRate"/> is less than 0.
+        /// <para>-or-</para>
+        /// <para>If <paramref name="maxConnections"/> is less than 0.</para>
+        /// <para>-or-</para>
+        /// <para>If <paramref name="minConnections"/> is less than 0.</para>
+        /// <para>-or-</para>
+        /// <para>If <paramref name="rateInterval"/> is negative or <see cref="TimeSpan.Zero"/>.</para>
+        /// </exception>
+        public ConnectionThrottles(int? maxConnectionRate, int? maxConnections, int? minConnections, TimeSpan? rateInterval)
+        {
+            if (maxConnectionRate < 0)
+                throw new ArgumentOutOfRangeException("maxConnectionRate");
+            if (maxConnections < 0)
+                throw new ArgumentOutOfRangeException("maxConnections");
+            if (minConnections < 0)
+                throw new ArgumentOutOfRangeException("minConnections");
+            if (rateInterval <= TimeSpan.Zero)
+                throw new ArgumentOutOfRangeException("rateInterval");
+
+            _maxConnectionRate = maxConnectionRate;
+            _maxConnections = maxConnections;
+            _minConnections = minConnections;
+            _rateInterval = rateInterval != null ? (int?)rateInterval.Value.TotalSeconds : default(int?);
+        }
+
+        /// <summary>
+        /// Gets the maximum number of connections allowed from a single IP address in the defined <see cref="RateInterval"/>.
+        /// A value of 0 indicates an unlimited connection rate. A value of <c>null</c> indicates this connection limit is
+        /// not configured.
+        /// </summary>
+        /// <value>
+        /// The maximum number of connections allowed from a single IP address in the defined <see cref="RateInterval"/>,
+        /// or one of the following values:
+        ///
+        /// <list type="bullet">
+        /// <item>0, if the connection rate is configured but unlimited.</item>
+        /// <item><c>null</c>, if the connection rate limit is not configured.</item>
+        /// </list>
+        /// </value>
+        public int? MaxConnectionRate
+        {
+            get
+            {
+                return _maxConnectionRate;
+            }
+        }
+
+        /// <summary>
+        /// Gets the maximum number of connections allowed for a single IP address. A value of 0 indicates
+        /// an unlimited number of connections. A value of <c>null</c> indicates this connection limit is
+        /// not configured.
+        /// </summary>
+        public int? MaxConnections
+        {
+            get
+            {
+                return _maxConnections;
+            }
+        }
+
+        /// <summary>
+        /// Gets the minimum number of connections to allow from an IP address before applying throttling restrictions.
+        /// A value of <c>null</c> indicates this connection limit is not configured.
+        /// </summary>
+        public int? MinConnections
+        {
+            get
+            {
+                return _minConnections;
+            }
+        }
+
+        /// <summary>
+        /// Gets the time period for which <see cref="MaxConnectionRate"/> is evaluated. For example, a <see cref="MaxConnectionRate"/>
+        /// of 30 with a <see cref="RateInterval"/> of 60 seconds would allow a maximum of 30 connections per minute from a single IP
+        /// address. A value of <c>null</c> indicates this connection limit is not configured.
+        /// </summary>
+        public TimeSpan? RateInterval
+        {
+            get
+            {
+                if (_rateInterval == null)
+                    return null;
+
+                return TimeSpan.FromSeconds(_rateInterval.Value);
+            }
+        }
+    }
+}