Merge pull request #609 from openstacknetsdk/floating-ips-44

Implement Layer3 Networking Extension

Author: carolynvs

src/corelib/Compute/v2_1/Actions/AssociateFloatingIPRequest.cs

@@ -0,0 +1,33 @@
+using Newtonsoft.Json;
+using OpenStack.Serialization;
+
+namespace OpenStack.Compute.v2_1
+{
+    /// <summary>
+    /// Associates a floating IP address to a server.
+    /// </summary>
+    [JsonConverterWithConstructor(typeof(RootWrapperConverter), "addFloatingIp")]
+    public class AssociateFloatingIPRequest
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AssociateFloatingIPRequest"/> class.
+        /// </summary>
+        /// <param name="floatingIPAddress">The floating ip address.</param>
+        public AssociateFloatingIPRequest(string floatingIPAddress)
+        {
+            FloatingIPAddress = floatingIPAddress;
+        }
+
+        /// <summary>
+        /// The floating IP address.
+        /// </summary>
+        [JsonProperty("address")]
+        public string FloatingIPAddress { get; set; }
+
+        /// <summary>
+        /// The fixed IP address with which you want to associate the floating IP address.
+        /// </summary>
+        [JsonProperty("fixed_address")]
+        public string FixedIPAddress { get; set; }
+    }
+}

src/corelib/Compute/v2_1/ComputeService.cs

@@ -109,7 +109,6 @@ public ComputeService(IAuthenticationProvider authenticationProvider, string reg
             return _computeApi.DeleteServerMetadataAsync(serverId, key, cancellationToken);
         }
 
-
         /// <inheritdoc cref="ComputeApi.WaitUntilServerIsDeletedAsync{TServer,TStatus}" />
         public Task WaitUntilServerIsDeletedAsync(Identifier serverId, TimeSpan? refreshDelay = null, TimeSpan? timeout = null, IProgress<bool> progress = null, CancellationToken cancellationToken = default(CancellationToken))
         {
@@ -212,6 +211,18 @@ public ComputeService(IAuthenticationProvider authenticationProvider, string reg
             return _computeApi.CancelResizeServerAsync(serverId, cancellationToken);
         }
 
+        /// <inheritdoc cref="ComputeApi.AssociateFloatingIPAsync" />
+        public virtual Task AssociateFloatingIPAddressAsync(Identifier serverId, AssociateFloatingIPRequest request, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return _computeApi.AssociateFloatingIPAsync(serverId, request, cancellationToken);
+        }
+
+        /// <inheritdoc cref="ComputeApi.DisassociateFloatingIPAsync" />
+        public virtual Task DisassociateFloatingIPAsync(Identifier serverId, string floatingIPAddress, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return _computeApi.DisassociateFloatingIPAsync(serverId, floatingIPAddress, cancellationToken);
+        }
+
         /// <inheritdoc cref="ComputeApi.ListServerActionSummariesAsync{T}" />
         public virtual async Task<IEnumerable<ServerActionSummary>> ListServerActionSummariesAsync(Identifier serverId, CancellationToken cancellationToken = default(CancellationToken))
         {

src/corelib/Compute/v2_1/ComputeServiceExtensions.cs

@@ -181,6 +181,18 @@ public static void CancelResizeServer(this ComputeService service, Identifier se
             service.CancelResizeServerAsync(serverId).ForceSynchronous();
         }
 
+        /// <inheritdoc cref="ComputeService.AssociateFloatingIPAddressAsync" />
+        public static void AssociateFloatingIPAddressAsync(this ComputeService service, Identifier serverId, AssociateFloatingIPRequest request)
+        {
+            service.AssociateFloatingIPAddressAsync(serverId, request).ForceSynchronous();
+        }
+
+        /// <inheritdoc cref="ComputeService.DisassociateFloatingIPAsync" />
+        public static void DisassociateFloatingIPAsync(this ComputeService service, Identifier serverId, string floatingIPAddress)
+        {
+            service.DisassociateFloatingIPAsync(serverId, floatingIPAddress).ForceSynchronous();
+        }
+
         /// <inheritdoc cref="ComputeService.ListServerActionSummariesAsync" />
         public static IEnumerable<ServerActionSummary> ListServerActions(this ComputeService service, Identifier serverId)
         {

src/corelib/Compute/v2_1/Serialization/ComputeApi.cs

@@ -765,6 +765,37 @@ protected ComputeApi(IServiceType serviceType, IAuthenticationProvider authentic
                 .SendAsync();
         }
 
+        /// <summary>
+        /// Associates a floating IP address to the server.
+        /// </summary>
+        /// <param name="serverId">The server identifier.</param>
+        /// <param name="request">The request.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public virtual Task AssociateFloatingIPAsync(string serverId, object request, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return BuildServerActionRequest(serverId, request, cancellationToken).SendAsync();
+        }
+
+        /// <summary>
+        /// Disassociate a floating IP address from a server.
+        /// </summary>
+        /// <param name="serverId">The server identifier.</param>
+        /// <param name="floatingIPAddress">The floating IP address to remove.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public virtual Task DisassociateFloatingIPAsync(string serverId, string floatingIPAddress, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var request = new
+            {
+                removeFloatingIp = new
+                {
+                    address = floatingIPAddress
+                }
+            };
+            return BuildServerActionRequest(serverId, request, cancellationToken).SendAsync();
+        }
+
         /// <summary>
         /// Builds a server action request, where the server operation is specified in the request body.
         /// </summary>

src/corelib/Compute/v2_1/Server.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Extensions;
+using System.Linq;
 using System.Runtime.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
@@ -231,15 +232,46 @@ public string AdminPassword
 
         /// <inheritdoc cref="ComputeApi.AttachVolumeAsync{T}" />
         /// <exception cref="InvalidOperationException">When this instance was not constructed by the <see cref="ComputeService"/>, as it is missing the appropriate internal state to execute service calls.</exception>
-        public virtual async Task<ServerVolume> AttachVolumeAsync(ServerVolumeDefinition volume, CancellationToken cancellationToken = default(CancellationToken))
+        public async Task<ServerVolume> AttachVolumeAsync(ServerVolumeDefinition volume, CancellationToken cancellationToken = default(CancellationToken))
         {
             var compute = this.GetOwnerOrThrow<ComputeApi>();
             var result = await compute.AttachVolumeAsync<ServerVolume>(Id, volume, cancellationToken).ConfigureAwait(false);
             AttachedVolumes.Add(result);
             ((IChildResource)result).SetParent(this);
             return result;
         }
-        
+
+        /// <inheritdoc cref="ComputeApi.AssociateFloatingIPAsync" />
+        /// <exception cref="InvalidOperationException">When this instance was not constructed by the <see cref="ComputeService"/>, as it is missing the appropriate internal state to execute service calls.</exception>
+        public virtual async Task AssociateFloatingIPAsync(AssociateFloatingIPRequest request, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var compute = this.GetOwnerOrThrow<ComputeApi>();
+            await compute.AssociateFloatingIPAsync(Id, request, cancellationToken);
+
+            Addresses = await compute.ListServerAddressesAsync<ServerAddressCollection>(Id, cancellationToken);
+        }
+
+        /// <inheritdoc cref="ComputeApi.DisassociateFloatingIPAsync" />
+        /// <exception cref="InvalidOperationException">When this instance was not constructed by the <see cref="ComputeService"/>, as it is missing the appropriate internal state to execute service calls.</exception>
+        public virtual async Task DisassociateFloatingIPAsync(string floatingIPAddress, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var compute = this.GetOwnerOrThrow<ComputeApi>();
+            await compute.DisassociateFloatingIPAsync(Id, floatingIPAddress, cancellationToken);
+
+            // Remove the address from the current instance immediately
+            foreach (KeyValuePair<string, IList<ServerAddress>> group in Addresses)
+            {
+                foreach (ServerAddress address in group.Value)
+                {
+                    if (address.Type == AddressType.Floating && address.IP == floatingIPAddress)
+                    {
+                        Addresses[group.Key].Remove(address);
+                        return;
+                    }
+                }
+            }
+        }
+
         /// <summary />
         [OnDeserialized]
         private void OnDeserializedMethod(StreamingContext context)

src/corelib/Compute/v2_1/ServerExtensions.cs

@@ -185,6 +185,18 @@ public static void CancelResize(this ServerReference server)
             server.CancelResizeAsync().ForceSynchronous();
         }
 
+        /// <inheritdoc cref="Server.AssociateFloatingIPAsync"/>
+        public static void AssociateFloatingIP(this Server server, AssociateFloatingIPRequest request)
+        {
+            server.AssociateFloatingIPAsync(request).ForceSynchronous();
+        }
+
+        /// <inheritdoc cref="Server.DisassociateFloatingIPAsync"/>
+        public static void DisassociateFloatingIP(this Server server, string floatingIPAddress)
+        {
+            server.DisassociateFloatingIPAsync(floatingIPAddress).ForceSynchronous();
+        }
+
         /// <inheritdoc cref="ServerReference.ListActionSummariesAsync"/>
         public static IEnumerable<ServerActionSummary> ListActionSummaries(this ServerReference server)
         {

src/corelib/Networking/v2/Layer3/ExternalGateway.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace OpenStack.Networking.v2.Layer3
+{
+    /// <summary>
+    /// Defines a connection from a router to an external network.
+    /// </summary>
+    public class ExternalGateway
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExternalGateway"/> class.
+        /// </summary>
+        public ExternalGateway()
+        {
+            ExternalFixedIPs = new List<IPAddressAssociation>();
+        }
+
+        /// <summary>
+        /// The external network identifier.
+        /// </summary>
+        [JsonProperty("network_id")]
+        public Identifier ExternalNetworkId { get; set; }
+
+        /// <summary>
+        /// Specifies if source NAT is enabled
+        /// </summary>
+        [JsonProperty("enable_snat")]
+        public bool IsSourceNATEnabled { get; set; }
+
+        /// <summary>
+        /// External fixed IP addresses assigned to the router.
+        /// </summary>
+        [JsonProperty("external_fixed_ips")]
+        public IList<IPAddressAssociation> ExternalFixedIPs { get; set; }
+    }
+}

src/corelib/Networking/v2/Layer3/ExternalGatewayDefinition.cs

@@ -0,0 +1,38 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace OpenStack.Networking.v2.Layer3
+{
+    /// <summary>
+    /// Defines the set of fields that can be updated on an external gateway resource.
+    /// </summary>
+    public class ExternalGatewayDefinition
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExternalGateway"/> class.
+        /// </summary>
+        public ExternalGatewayDefinition(Identifier externalNetworkId)
+        {
+            ExternalNetworkId = externalNetworkId;
+            ExternalFixedIPs = new List<IPAddressAssociation>();
+        }
+
+        /// <summary>
+        /// The external network identifier.
+        /// </summary>
+        [JsonProperty("network_id")]
+        public Identifier ExternalNetworkId { get; set; }
+
+        /// <summary>
+        /// Specifies if source NAT is enabled
+        /// </summary>
+        [JsonProperty("enable_snat")]
+        public bool? IsSourceNATEnabled { get; set; }
+
+        /// <summary>
+        /// External fixed IP addresses assigned to the router.
+        /// </summary>
+        [JsonProperty("external_fixed_ips")]
+        public IList<IPAddressAssociation> ExternalFixedIPs { get; set; }
+    }
+}

src/corelib/Networking/v2/Layer3/FloatingIP.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Extensions;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using OpenStack.Serialization;
+
+namespace OpenStack.Networking.v2.Layer3
+{
+    /// <summary>
+    /// An external IP address that you map to a port in an internal network
+    /// </summary>
+    [JsonConverterWithConstructor(typeof(RootWrapperConverter), "floatingip")]
+    public class FloatingIP : IHaveExtraData, IServiceResource
+    {
+        /// <summary>
+        /// The floating IP identifier.
+        /// </summary>
+        [JsonProperty("id")]
+        public Identifier Id { get; set; }
+
+        /// <summary>
+        /// The associated router.
+        /// </summary>
+        [JsonProperty("router_id")]
+        public Identifier RouterId { get; set; }
+
+        /// <summary>
+        /// The network associated with the floating IP. 
+        /// </summary>
+        [JsonProperty("floating_network_id")]
+        public Identifier NetworkId { get; set; }
+
+        /// <summary>
+        /// The fixed IP address that is associated with the floating IP address. 
+        /// </summary>
+        [JsonProperty("fixed_ip_address")]
+        public string FixedIPAddress { get; set; }
+
+        /// <summary>
+        /// The floating IP address.
+        /// </summary>
+        [JsonProperty("floating_ip_address")]
+        public string FloatingIPAddress { get; set; }
+
+        /// <summary>
+        /// The associated port.
+        /// </summary>
+        [JsonProperty("port_id")]
+        public Identifier PortId { get; set; }
+
+        /// <summary>
+        /// The status of the floating IP address.
+        /// </summary>
+        [JsonProperty("status")]
+        public FloatingIPStatus Status { get; set; }
+
+        [JsonExtensionData]
+        IDictionary<string, JToken> IHaveExtraData.Data { get; set; } = new Dictionary<string, JToken>();
+
+        object IServiceResource.Owner { get; set; }
+
+        /// <inheritdoc cref="NetworkingApiBuilder.DeleteFloatingIPAsync"/>
+        /// <exception cref="InvalidOperationException">Thrown when a resource as not constructed by the SDK.</exception>
+        public Task DeleteAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var networking = this.GetOwnerOrThrow<NetworkingApiBuilder>();
+            return networking.DeleteFloatingIPAsync(Id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Associates the floating IP withe the specified port.
+        /// </summary>
+        /// <param name="portId">The port identifier.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <exception cref="InvalidOperationException">Thrown when a resource as not constructed by the SDK.</exception>
+        public async Task AssociateAsync(Identifier portId, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var networking = this.GetOwnerOrThrow<NetworkingApiBuilder>();
+            var request = new FloatingIPUpdateDefinition { PortId = portId };
+            var result = await networking.UpdateFloatingIPAsync<FloatingIP>(Id, request, cancellationToken).ConfigureAwait(false);
+            result.CopyProperties(this);
+        }
+
+        /// <summary>
+        /// Frees the floating IP from any associations.
+        /// </summary>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <exception cref="InvalidOperationException">Thrown when a resource as not constructed by the SDK.</exception>
+        public async Task DisassociateAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var networking = this.GetOwnerOrThrow<NetworkingApiBuilder>();
+            var request = new FloatingIPUpdateDefinition { PortId = null };
+            var result = await networking.UpdateFloatingIPAsync<FloatingIP>(Id, request, cancellationToken).ConfigureAwait(false);
+            result.CopyProperties(this);
+        }
+    }
+}