[Delivers #43560233] Create Volume functionality

src/corelib/Core/Domain/CloudBlockStorageVolume.cs

@@ -0,0 +1,23 @@
+using System.Runtime.Serialization;
+
+namespace net.openstack.Core.Domain
+{
+    [DataContract]
+    public class CreateCloudBlockStorageVolumeDetails
+    {
+        [DataMember(Name = "size")]
+        public int Size { get; set; }
+
+        [DataMember(Name = "display_description")]
+        public string DisplayDescription { get; set; }
+
+        [DataMember(Name = "display_name")]
+        public string DisplayName { get; set; }
+
+        [DataMember(Name = "snapshot_id")]
+        public string SnapshotId { get; set; }
+
+        [DataMember(Name = "volume_type")]
+        public string VolumeType { get; set; }
+    }
+}

src/corelib/Core/Domain/CloudBlockStorageVolumeType.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace net.openstack.Core.Domain
+{
+    public class CloudBlockStorageVolumeType
+    {   
+        public static string SSD { get { return "SSD"; } }
+        public static string SATA { get { return "SATA"; } }
+    }
+}

src/corelib/Core/ICloudBlockStorageProvider.cs

@@ -1,15 +1,9 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using net.openstack.Core.Domain;
 
 namespace net.openstack.Core
 {
     public interface ICloudBlockStorageProvider
     {
-
-
-
-
+        bool CreateVolume(int size, string display_description = null, string display_name = null, string snapshot_id = null, string volume_type = null, string region = null, CloudIdentity identity = null);
     }
 }

src/corelib/Core/ICloudBlockStorageValidator.cs

@@ -2,6 +2,6 @@
 {
     public interface ICloudBlockStorageValidator
     {
-
+        void ValidateVolumeSize(int size);
     }
 }

src/corelib/Providers/Rackspace/CloudBlockStorageProvider.cs

@@ -1,14 +1,18 @@
-using JSIStudios.SimpleRESTServices.Client;
+using System;
+using System.Linq;
+using JSIStudios.SimpleRESTServices.Client;
 using JSIStudios.SimpleRESTServices.Client.Json;
 using net.openstack.Core;
 using net.openstack.Core.Domain;
+using net.openstack.Providers.Rackspace.Objects.Request;
 using net.openstack.Providers.Rackspace.Validators;
 
 namespace net.openstack.Providers.Rackspace
 {
     public class CloudBlockStorageProvider : ProviderBase, ICloudBlockStorageProvider
     {
 
+        private readonly int[] _validResponseCode = new[] { 200 };
         private readonly ICloudBlockStorageValidator _cloudBlockStorageValidator;
 
         public CloudBlockStorageProvider()
@@ -17,17 +21,26 @@ public CloudBlockStorageProvider()
         public CloudBlockStorageProvider(CloudIdentity defaultIdentity)
             : this(defaultIdentity, new IdentityProvider(), new JsonRestServices(), new CloudBlockStorageValidator()) { }
 
-        public CloudBlockStorageProvider(IIdentityProvider identityProvider, IRestService restService, ICloudBlockStorageValidator cloudBlockStorageValidator)
+        internal CloudBlockStorageProvider(IIdentityProvider identityProvider, IRestService restService, ICloudBlockStorageValidator cloudBlockStorageValidator)
             : this(null, identityProvider, restService, cloudBlockStorageValidator) { }
 
-        public CloudBlockStorageProvider(CloudIdentity defaultIdentity, IIdentityProvider identityProvider, IRestService restService, ICloudBlockStorageValidator cloudBlockStorageValidator)
+        internal CloudBlockStorageProvider(CloudIdentity defaultIdentity, IIdentityProvider identityProvider, IRestService restService, ICloudBlockStorageValidator cloudBlockStorageValidator)
             : base(defaultIdentity, identityProvider, restService)
         {
             _cloudBlockStorageValidator = cloudBlockStorageValidator;
         }
 
 
+        public bool CreateVolume(int size, string display_description = null, string display_name = null, string snapshot_id = null, string volume_type = null, string region = null, CloudIdentity identity = null)
+        {
+            _cloudBlockStorageValidator.ValidateVolumeSize(size);
+
+            var urlPath = new Uri(string.Format("{0}/volumes", GetServiceEndpoint(identity, region)));
+            var requestBody = new CreateCloudBlockStorageVolumeRequest { CreateCloudBlockStorageVolumeDetails = new CreateCloudBlockStorageVolumeDetails { Size = size, DisplayDescription = display_description, DisplayName = display_name, SnapshotId = snapshot_id, VolumeType = volume_type } };
+            var response = ExecuteRESTRequest(identity, urlPath, HttpMethod.POST, requestBody);
 
+            return response != null && _validResponseCode.Contains(response.StatusCode);
+        }
 
         #region Private methods
 

src/corelib/Providers/Rackspace/Objects/Request/CreateCloudBlockStorageVolumeRequest.cs

@@ -0,0 +1,12 @@
+using System.Runtime.Serialization;
+using net.openstack.Core.Domain;
+
+namespace net.openstack.Providers.Rackspace.Objects.Request
+{
+    [DataContract]
+    internal class CreateCloudBlockStorageVolumeRequest
+    {
+        [DataMember(Name = "volume")]
+        public CreateCloudBlockStorageVolumeDetails CreateCloudBlockStorageVolumeDetails { get; set; } 
+    }
+}

src/corelib/Providers/Rackspace/Validators/CloudBlockStorageValidator.cs

@@ -8,5 +8,10 @@ namespace net.openstack.Providers.Rackspace.Validators
 {
     public class CloudBlockStorageValidator : ICloudBlockStorageValidator
     {
+        public void ValidateVolumeSize(int size)
+        {   
+            if (size < 100 || size > 1000)
+                throw new ArgumentException("ERROR: The volume size value must be between 100 and 1000");
+        }
     }
 }

src/corelib/corelib.csproj

@@ -45,7 +45,8 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Core\Domain\Address.cs" />
-    <Compile Include="Core\Domain\CloudBlockStorage.cs" />
+    <Compile Include="Core\Domain\CloudBlockStorageVolume.cs" />
+    <Compile Include="Core\Domain\CloudBlockStorageVolumeType.cs" />
     <Compile Include="Core\Domain\CloudIdentity.cs" />
     <Compile Include="Core\Domain\Container.cs" />
     <Compile Include="Core\Domain\Flavor.cs" />
@@ -86,6 +87,7 @@
     <Compile Include="Providers\Rackspace\Objects\Request\AddRoleRequest.cs" />
     <Compile Include="Providers\Rackspace\Objects\Request\AddUserRequest.cs" />
     <Compile Include="Providers\Rackspace\Objects\Request\ConfirmServerResizeRequest.cs" />
+    <Compile Include="Providers\Rackspace\Objects\Request\CreateCloudBlockStorageVolumeRequest.cs" />
     <Compile Include="Providers\Rackspace\Objects\Request\CreateServerImageDetails.cs" />
     <Compile Include="Providers\Rackspace\Objects\Request\CreateServerImageRequest.cs" />
     <Compile Include="Providers\Rackspace\Objects\Request\ChangeServerAdminPasswordRequest.cs" />

src/testing/integration/Providers/Rackspace/CloudBlockStorageTests.cs

@@ -11,6 +11,8 @@ public class CloudBlockStorageTests
         private static RackspaceCloudIdentity _testIdentity;
         private static RackspaceCloudIdentity _testAdminIdentity;
         private TestContext testContextInstance;
+        private const string volumeDisplayName = "Test Volume";
+        private const string volumeDisplayDescription = "Test Volume Description";
 
         /// <summary>
         ///Gets or sets the test context which provides
@@ -33,6 +35,25 @@ public static void Init(TestContext context)
         {
             _testIdentity = new RackspaceCloudIdentity(Bootstrapper.Settings.TestIdentity);
 
+        }
+
+
+        #region Create Volume Tests
+        [TestMethod]
+        public void Should_Create_Volume_Only_Required_Parameters()
+        {
+            var provider = new CloudBlockStorageProvider();
+            var volumeCreatedResponse = provider.CreateVolume(100, identity: _testIdentity);
+            Assert.IsTrue(volumeCreatedResponse);
+        }
+
+        [TestMethod]
+        public void Should_Create_Volume_Full_Parameters()
+        {
+            var provider = new CloudBlockStorageProvider();
+            var volumeCreatedResponse = provider.CreateVolume(100, volumeDisplayDescription, volumeDisplayName, null, CloudBlockStorageVolumeType.SATA, null, _testIdentity);
+            Assert.IsTrue(volumeCreatedResponse);
         } 
+        #endregion
     }
 }

src/testing/unit/Providers/Rackspace/CloudBlockStorageTests.cs

@@ -1,10 +1,63 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using net.openstack.Providers.Rackspace.Validators;
 
 namespace OpenStackNet.Testing.Unit.Providers.Rackspace
 {
     [TestClass]
     public class CloudBlockStorageTests
     {
-
+        [TestMethod]
+        public void Should_Not_Throw_Exception_When_Size_Is_In_Range()
+        {
+            const int size = 900;
+
+            try
+            {
+                var cloudBlockStorageValidator = new CloudBlockStorageValidator();
+                cloudBlockStorageValidator.ValidateVolumeSize(size);
+            }
+            catch (Exception ex)
+            {
+
+                Assert.Fail("Exception should not be thrown.");
+            }
+        }
+
+        [TestMethod]
+        public void Should_Throw_Exception_When_Size_Is_Less_Than_100()
+        {
+            const int size = 50;
+
+            try
+            {
+                var cloudBlockStorageValidator = new CloudBlockStorageValidator();
+                cloudBlockStorageValidator.ValidateVolumeSize(size);
+                Assert.Fail("Expected was not thrown.");
+            }
+            catch (Exception ex)
+            {
+
+                Assert.AreEqual("ERROR: The volume size value must be between 100 and 1000", ex.Message);
+            }
+        }
+
+        [TestMethod]
+        public void Should_Throw_Exception_When_Size_Is_Greater_Than_1000()
+        {
+            const int size = 1050;
+
+            try
+            {
+                var cloudBlockStorageValidator = new CloudBlockStorageValidator();
+                cloudBlockStorageValidator.ValidateVolumeSize(size);
+                Assert.Fail("Expected  was not thrown.");
+            }
+            catch (Exception ex)
+            {
+
+                Assert.AreEqual("ERROR: The volume size value must be between 100 and 1000", ex.Message);
+            }
+        }    
     }
 }