Compute.Suspend/ResumeServer

Author: carolynvs

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

@@ -0,0 +1,14 @@
+using Newtonsoft.Json;
+
+namespace OpenStack.Compute.v2_1
+{
+    /// <summary>
+    /// Resumes a suspended server and changes its status to ACTIVE.
+    /// </summary>
+    public class ResumeServerRequest
+    {
+        /// <summary />
+        [JsonProperty("resume", DefaultValueHandling = DefaultValueHandling.Include, NullValueHandling = NullValueHandling.Include)]
+        public string Action { get; set; }
+    }
+}

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

@@ -0,0 +1,14 @@
+using Newtonsoft.Json;
+
+namespace OpenStack.Compute.v2_1
+{
+    /// <summary>
+    /// Suspends a server and changes its status to SUSPENDED.
+    /// </summary>
+    public class SuspendServerRequest
+    {
+        /// <summary />
+        [JsonProperty("suspend", DefaultValueHandling = DefaultValueHandling.Include, NullValueHandling = NullValueHandling.Include)]
+        public string Action { get; set; }
+    }
+}

src/corelib/Compute/v2_1/ComputeService.cs

@@ -134,6 +134,18 @@ public ComputeService(IAuthenticationProvider authenticationProvider, string reg
             return _computeApi.StopServerAsync(serverId, cancellationToken);
         }
 
+        /// <inheritdoc cref="ComputeApi.SuspendServerAsync" />
+        public Task SuspendServerAsync(Identifier serverId, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return _computeApi.SuspendServerAsync(serverId, cancellationToken);
+        }
+
+        /// <inheritdoc cref="ComputeApi.ResumeServerAsync" />
+        public Task ResumeServerAsync(Identifier serverId, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return _computeApi.ResumeServerAsync(serverId, cancellationToken);
+        }
+
         /// <inheritdoc cref="ComputeApi.RebootServerAsync{TRequest}" />
         public Task RebootServerAsync(Identifier serverId, RebootServerRequest request = null, CancellationToken cancellationToken = default(CancellationToken))
         {

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

@@ -554,6 +554,28 @@ protected ComputeApi(IServiceType serviceType, IAuthenticationProvider authentic
             return BuildServerActionRequest(serverId, request, cancellationToken).SendAsync();
         }
 
+        /// <summary>
+        /// Suspends a server and changes its status to SUSPENDED.
+        /// </summary>
+        /// <param name="serverId">The server identifier.</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 SuspendServerAsync(string serverId, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var request = new SuspendServerRequest();
+            return BuildServerActionRequest(serverId, request, cancellationToken).SendAsync();
+        }
+
+        /// <summary>
+        /// Resumes a suspended server and changes its status to ACTIVE.
+        /// </summary>
+        /// <param name="serverId">The server identifier.</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 ResumeServerAsync(string serverId, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var request = new ResumeServerRequest();
+            return BuildServerActionRequest(serverId, request, cancellationToken).SendAsync();
+        }
+
         /// <summary>
         /// Reboots a server.
         /// </summary>

src/corelib/Compute/v2_1/ServerExtensions.cs

@@ -95,6 +95,18 @@ public static void Stop(this ServerReference server)
             server.StopAsync().ForceSynchronous();
         }
 
+        /// <inheritdoc cref="ServerReference.SuspendAsync"/>
+        public static void Suspend(this ServerReference server)
+        {
+            server.SuspendAsync().ForceSynchronous();
+        }
+
+        /// <inheritdoc cref="ServerReference.ResumeAsync"/>
+        public static void Resume(this ServerReference server)
+        {
+            server.ResumeAsync().ForceSynchronous();
+        }
+
         /// <inheritdoc cref="ServerReference.RebootAsync"/>
         public static void Reboot(this ServerReference server, RebootServerRequest request = null)
         {

src/corelib/Compute/v2_1/ServerReference.cs

@@ -103,6 +103,22 @@ public class ServerReference : IHaveExtraData, IServiceResource
             await compute.StopServerAsync(Id, cancellationToken).ConfigureAwait(false);
         }
 
+        /// <inheritdoc cref="ComputeApi.SuspendServerAsync" />
+        /// <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 async Task SuspendAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var compute = this.GetOwnerOrThrow<ComputeApi>();
+            await compute.SuspendServerAsync(Id, cancellationToken).ConfigureAwait(false);
+        }
+
+        /// <inheritdoc cref="ComputeApi.ResumeServerAsync" />
+        /// <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 async Task ResumeAsync(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            var compute = this.GetOwnerOrThrow<ComputeApi>();
+            await compute.ResumeServerAsync(Id, cancellationToken).ConfigureAwait(false);
+        }
+
         /// <inheritdoc cref="ComputeApi.RebootServerAsync{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 async Task RebootAsync(RebootServerRequest request = null, CancellationToken cancellationToken = default(CancellationToken))

src/corelib/OpenStack.csproj

@@ -91,9 +91,11 @@
     <Compile Include="Compute\v2_1\Actions\RescueServerRequest.cs" />
     <Compile Include="Compute\v2_1\Actions\RebootServerRequest.cs" />
     <Compile Include="Compute\v2_1\Actions\RebootType.cs" />
+    <Compile Include="Compute\v2_1\Actions\ResumeServerRequest.cs" />
     <Compile Include="Compute\v2_1\Actions\SnapshotServerRequest.cs" />
     <Compile Include="Compute\v2_1\Actions\StartServerRequest.cs" />
     <Compile Include="Compute\v2_1\Actions\StopServerRequest.cs" />
+    <Compile Include="Compute\v2_1\Actions\SuspendServerRequest.cs" />
     <Compile Include="Compute\v2_1\AddressType.cs" />
     <Compile Include="Compute\v2_1\Flavor.cs" />
     <Compile Include="Compute\v2_1\FlavorReference.cs" />

src/testing/integration/Compute/v2_1/ServerTests.cs

@@ -323,7 +323,23 @@ public async Task RebootServerTest()
             await server.WaitForStatusAsync(ServerStatus.Reboot);
             await server.WaitUntilActiveAsync();
         }
-        
+
+        [Fact]
+        public async Task ResumeServerTest()
+        {
+            Trace.WriteLine("Creating server...");
+            var server = await _testData.CreateServer();
+            await server.WaitUntilActiveAsync();
+
+            Trace.WriteLine("Suspending the server...");
+            await server.SuspendAsync();
+            await server.WaitForStatusAsync(ServerStatus.Suspended);
+
+            Trace.WriteLine("Resuming the server...");
+            await server.ResumeAsync();
+            await server.WaitUntilActiveAsync();
+        }
+
         [Fact]
         public async Task ServerVolumesTest()
         {

src/testing/unit/Compute/v2_1/ServerTests.cs

@@ -484,6 +484,40 @@ public void StopServer()
             }
         }
 
+        [Fact]
+        public void SuspendServer()
+        {
+            using (var httpTest = new HttpTest())
+            {
+                Identifier serverId = Guid.NewGuid();
+                httpTest.RespondWithJson(new Server { Id = serverId });
+                httpTest.RespondWith((int)HttpStatusCode.Accepted, "Roger that, boss");
+
+                var server = _compute.GetServer(serverId);
+                server.Suspend();
+
+                httpTest.ShouldHaveCalled($"*/servers/{serverId}/action");
+                Assert.True(httpTest.CallLog.Last().RequestBody.Contains("suspend"));
+            }
+        }
+
+        [Fact]
+        public void ResumeServer()
+        {
+            using (var httpTest = new HttpTest())
+            {
+                Identifier serverId = Guid.NewGuid();
+                httpTest.RespondWithJson(new Server { Id = serverId });
+                httpTest.RespondWith((int)HttpStatusCode.Accepted, "Roger that, boss");
+
+                var server = _compute.GetServer(serverId);
+                server.Resume();
+
+                httpTest.ShouldHaveCalled($"*/servers/{serverId}/action");
+                Assert.True(httpTest.CallLog.Last().RequestBody.Contains("resume"));
+            }
+        }
+
         [Fact]
         public void RebootServer()
         {