Support server.AssociateFloatingIP action

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,12 @@ 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.ListServerActionSummariesAsync{T}" />
         public virtual async Task<IEnumerable<ServerActionSummary>> ListServerActionSummariesAsync(Identifier serverId, CancellationToken cancellationToken = default(CancellationToken))
         {

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

@@ -765,6 +765,17 @@ protected ComputeApi(IServiceType serviceType, IAuthenticationProvider authentic
                 .SendAsync();
         }
 
+        /// <summary>
+        /// Associates a floating IP address to the server instance.
+        /// </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>
+        public virtual Task AssociateFloatingIPAsync(string serverId, object request, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            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

@@ -231,15 +231,23 @@ 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 Task AssociateFloatingIPAsync(AssociateFloatingIPRequest request, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var compute = this.GetOwnerOrThrow<ComputeApi>();
+            return compute.AssociateFloatingIPAsync(Id, request, cancellationToken);
+        }
+
         /// <summary />
         [OnDeserialized]
         private void OnDeserializedMethod(StreamingContext context)

src/corelib/Compute/v2_1/ServerExtensions.cs

@@ -185,6 +185,12 @@ 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="ServerReference.ListActionSummariesAsync"/>
         public static IEnumerable<ServerActionSummary> ListActionSummaries(this ServerReference server)
         {

src/corelib/OpenStack.csproj

@@ -88,6 +88,7 @@
     <Compile Include="BlockStorage\v2\VolumeStatus.cs" />
     <Compile Include="Compute\ComputeOperationFailedException.cs" />
     <Compile Include="Compute\NamespaceDoc.cs" />
+    <Compile Include="Compute\v2_1\Actions\AssociateFloatingIPRequest.cs" />
     <Compile Include="Compute\v2_1\Actions\RescueServerRequest.cs" />
     <Compile Include="Compute\v2_1\Actions\RebootServerRequest.cs" />
     <Compile Include="Compute\v2_1\Actions\RebootType.cs" />

src/testing/unit/Networking/v2/Layer3/Level3ExtensionTests.cs

@@ -93,6 +93,32 @@ public void AssociateFloatingIP()
             }
         }
 
+        [Fact]
+        public void AssociateFloatingIPToServer()
+        {
+            var compute = new ComputeService(Stubs.AuthenticationProvider, "region");
+
+            using (var httpTest = new HttpTest())
+            {
+                Identifier serverId = Guid.NewGuid();
+                const string ip = "10.0.0.1";
+                httpTest.RespondWithJson(new Server { Id = serverId });
+                httpTest.RespondWith((int)HttpStatusCode.OK, "ip associated!");
+                httpTest.RespondWithJson(new ServerAddressCollection
+                {
+                    ["network1"] = new List<ServerAddress>
+                    {
+                        new ServerAddress {IP = ip, Type = AddressType.Floating}
+                    }
+                });
+
+                var server = compute.GetServer(serverId);
+                server.AssociateFloatingIP(new AssociateFloatingIPRequest(ip));
+
+                Assert.NotNull(server.Addresses["network1"].Single(a => a.IP == ip && a.Type == AddressType.Floating));
+            }
+        }
+
         [Fact]
         public void DisassociateFloatingIP()
         {
@@ -111,6 +137,35 @@ public void DisassociateFloatingIP()
             }
         }
 
+        [Fact]
+        public void DisassociateFloatingIPFromServer()
+        {
+            var compute = new ComputeService(Stubs.AuthenticationProvider, "region");
+
+            using (var httpTest = new HttpTest())
+            {
+                Identifier serverId = Guid.NewGuid();
+                const string ip = "10.0.0.1";
+                httpTest.RespondWithJson(new Server
+                {
+                    Id = serverId,
+                    Addresses =
+                    {
+                        ["network1"] = new List<ServerAddress>
+                        {
+                            new ServerAddress {IP = ip, Type = AddressType.Floating}
+                        }
+                    }
+                });
+                httpTest.RespondWith((int)HttpStatusCode.OK, "ip disassociated!");
+
+                var server = compute.GetServer(serverId);
+                server.DisassociateFloatingIP(ip);
+
+                Assert.Null(server.Addresses["network1"].FirstOrDefault(a => a.IP == ip && a.Type == AddressType.Floating));
+            }
+        }
+
         [Theory]
         [InlineData(HttpStatusCode.Accepted)]
         [InlineData(HttpStatusCode.NotFound)]