Merge pull request #602 from carolynvs/missing-userlevel-server-actions

Support Suspend/Resume Server

Author: carolynvs

src/corelib/Compute/v2_1/Actions/StartServerRequest.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/Actions/StopServerRequest.cs

@@ -539,7 +539,7 @@ protected ComputeApi(IServiceType serviceType, IAuthenticationProvider authentic
         /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
         public virtual Task StartServerAsync(string serverId, CancellationToken cancellationToken = default(CancellationToken))
         {
-            var request = new StartServerRequest();
+            var request = new Dictionary<string, object> {["os-start"] = "" };
             return BuildServerActionRequest(serverId, request, cancellationToken).SendAsync();
         }
 
@@ -550,7 +550,29 @@ protected ComputeApi(IServiceType serviceType, IAuthenticationProvider authentic
         /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
         public virtual Task StopServerAsync(string serverId, CancellationToken cancellationToken = default(CancellationToken))
         {
-            var request = new StopServerRequest();
+            var request = new Dictionary<string, object> {["os-stop"] = "" };
+            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 Dictionary<string, object> {["suspend"] = "" };
+            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 Dictionary<string, object> {["resume"] = "" };
             return BuildServerActionRequest(serverId, request, cancellationToken).SendAsync();
         }
 

src/corelib/Compute/v2_1/ComputeService.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/Serialization/ComputeApi.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/Compute/v2_1/ServerExtensions.cs

@@ -92,8 +92,6 @@
     <Compile Include="Compute\v2_1\Actions\RebootServerRequest.cs" />
     <Compile Include="Compute\v2_1\Actions\RebootType.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\AddressType.cs" />
     <Compile Include="Compute\v2_1\Flavor.cs" />
     <Compile Include="Compute\v2_1\FlavorReference.cs" />

src/corelib/Compute/v2_1/ServerReference.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/corelib/OpenStack.csproj

@@ -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()
         {