Compute os-snapshots

Place SnapshotStatus and VolumeStatus under the OpenStack.BlockStorage.v2
since these values are coming from cinder.

Author: carolynvs

src/corelib/BlockStorage/v2/Serialization/SnapshotStatus.cs

@@ -0,0 +1,35 @@
+using OpenStack.Serialization;
+
+namespace OpenStack.BlockStorage.v2.Serialization
+{
+    /// <summary />
+    /// <exclude />
+    public class SnapshotStatus<T> : ResourceStatus
+        where T : SnapshotStatus<T>, new()
+    {
+        /// <summary>
+        /// The snapshot is being created.
+        /// </summary>
+        public static readonly T Creating = new T {DisplayName = "creating"};
+
+        /// <summary>
+        /// The snapshot is ready to use.
+        /// </summary>
+        public static readonly T Available = new T {DisplayName = "available"};
+
+        /// <summary>
+        /// The snapshot is being deleted.
+        /// </summary>
+        public static readonly T Deleting = new T {DisplayName = "deleting"};
+
+        /// <summary>
+        /// A snapshot creation error occurred.
+        /// </summary>
+        public static readonly T Error = new T {DisplayName = "error", IsError = true};
+
+        /// <summary>
+        /// A snapshot deletion error occurred.
+        /// </summary>
+        public static readonly T ErrorDeleting = new T {DisplayName = "error_deleting", IsError = true};
+    }
+}

src/corelib/BlockStorage/v2/Serialization/VolumeStatus.cs

@@ -0,0 +1,65 @@
+using OpenStack.Serialization;
+
+namespace OpenStack.BlockStorage.v2.Serialization
+{
+    /// <summary />
+    /// <exclude />
+    public class VolumeStatus<T> : ResourceStatus
+        where T : VolumeStatus<T>, new()
+    {
+        /// <summary>
+        /// The volume is being created.
+        /// </summary>
+        public static readonly T Creating = new T {DisplayName = "creating"};
+
+        /// <summary>
+        /// The volume is ready to attach to an instance.
+        /// </summary>
+        public static readonly T Available = new T {DisplayName = "available"};
+
+        /// <summary>
+        /// The volume is attaching to an instance.
+        /// </summary>
+        public static readonly T Attaching = new T {DisplayName = "attaching"};
+
+        /// <summary>
+        /// The volume is attached to an instance.
+        /// </summary>
+        public static readonly T InUse = new T {DisplayName = "in-use"};
+
+        /// <summary>
+        /// The volume is being deleted.
+        /// </summary>
+        public static readonly T Deleting = new T {DisplayName = "deleting"};
+
+        /// <summary>
+        /// A volume creation error occurred.
+        /// </summary>
+        public static readonly T Error = new T {DisplayName = "error", IsError = true};
+
+        /// <summary>
+        /// A volume deletion error occurred.
+        /// </summary>
+        public static readonly T ErrorDeleting = new T {DisplayName = "error_deleting", IsError = true};
+
+        /// <summary>
+        /// A backup restoration error occurred.
+        /// </summary>
+        public static readonly T ErrorRestoring = new T {DisplayName = "error_restoring", IsError = true};
+
+        /// <summary>
+        /// An error occurred while attempting to extend a volume.
+        /// </summary>
+        public static readonly T ErrorExtending = new T {DisplayName = "error_extending", IsError = true};
+
+        /// <summary>
+        /// The volume is being backed up.
+        /// </summary>
+        public static readonly T BackingUp = new T {DisplayName = "backing-up"};
+
+        /// <summary>
+        /// A backup is being restored to the volume.
+        /// </summary>
+        public static readonly T RestoringBackup = new T {DisplayName = "restoring-backup"};
+    }
+}

src/corelib/BlockStorage/v2/SnapshotStatus.cs

@@ -0,0 +1,7 @@
+namespace OpenStack.BlockStorage.v2
+{
+    /// <summary/>
+    public class SnapshotStatus : Serialization.SnapshotStatus<SnapshotStatus>
+    {
+    }
+}

src/corelib/BlockStorage/v2/VolumeStatus.cs

@@ -0,0 +1,7 @@
+namespace OpenStack.BlockStorage.v2
+{
+    /// <summary/>
+    public class VolumeStatus : Serialization.VolumeStatus<VolumeStatus>
+    {
+    }
+}

src/corelib/Compute/v2_1/ComputeApiBuilder.cs

@@ -259,7 +259,7 @@ protected ComputeApiBuilder(IServiceType serviceType, IAuthenticationProvider au
         }
 
         /// <summary />
-        public virtual async Task<T> CreateSnapshotAsync<T>(string serverId, object request, CancellationToken cancellationToken = default(CancellationToken))
+        public virtual async Task<T> SnapshotServerAsync<T>(string serverId, object request, CancellationToken cancellationToken = default(CancellationToken))
             where T : IServiceResource
         {
             var response = await BuildServerActionAsync(serverId, request, cancellationToken).SendAsync();
@@ -1088,6 +1088,25 @@ protected ComputeApiBuilder(IServiceType serviceType, IAuthenticationProvider au
             return Endpoint.PrepareGetResourceRequest($"os-volume-types/{volumeTypeId}", cancellationToken);
         }
 
+        /// <summary />
+        public virtual async Task<T> GetVolumeSnapshotAsync<T>(string snapshotId, CancellationToken cancellationToken = default(CancellationToken))
+            where T : IServiceResource
+        {
+            return await BuildGetVolumeSnapshotRequest(snapshotId, cancellationToken)
+                .SendAsync()
+                .ReceiveJson<T>()
+                .PropogateOwner(this);
+        }
+
+        /// <summary />
+        public virtual Task<PreparedRequest> BuildGetVolumeSnapshotRequest(string snapshotId, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (snapshotId == null)
+                throw new ArgumentNullException("snapshotId");
+
+            return Endpoint.PrepareGetResourceRequest($"os-snapshots/{snapshotId}", cancellationToken);
+        }
+
         /// <summary />
         public virtual async Task<T> CreateVolumeAsync<T>(object volume, CancellationToken cancellationToken = default(CancellationToken))
             where T : IServiceResource
@@ -1107,6 +1126,25 @@ protected ComputeApiBuilder(IServiceType serviceType, IAuthenticationProvider au
             return Endpoint.PrepareCreateResourceRequest("os-volumes", volume, cancellationToken);
         }
 
+        /// <summary />
+        public virtual async Task<T> SnapshotVolumeAsync<T>(object snapshot, CancellationToken cancellationToken = default(CancellationToken))
+            where T : IServiceResource
+        {
+            return await BuildCreateVolumeSnapshotRequest(snapshot, cancellationToken)
+                .SendAsync()
+                .ReceiveJson<T>()
+                .PropogateOwner(this);
+        }
+
+        /// <summary />
+        public virtual async Task<PreparedRequest> BuildCreateVolumeSnapshotRequest(object snapshot, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if(snapshot == null)
+                throw new ArgumentNullException("snapshot");
+
+            return await Endpoint.PrepareCreateResourceRequest("os-snapshots", snapshot, cancellationToken);
+        }
+
         /// <summary />
         public virtual async Task<T> ListVolumesAsync<T>(CancellationToken cancellationToken = default(CancellationToken))
             where T : IEnumerable<IServiceResource>
@@ -1137,6 +1175,22 @@ protected ComputeApiBuilder(IServiceType serviceType, IAuthenticationProvider au
             return Endpoint.PrepareGetResourceRequest("os-volume-types", cancellationToken);
         }
 
+        /// <summary />
+        public virtual async Task<T> ListVolumeSnapshotsAsync<T>(CancellationToken cancellationToken = default(CancellationToken))
+            where T : IEnumerable<IServiceResource>
+        {
+            return await BuildListVolumeSnapshotsRequest(cancellationToken)
+                .SendAsync()
+                .ReceiveJson<T>()
+                .PropogateOwnerToChildren(this);
+        }
+
+        /// <summary />
+        public virtual Task<PreparedRequest> BuildListVolumeSnapshotsRequest(CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return Endpoint.PrepareGetResourceRequest("os-snapshots", cancellationToken);
+        }
+
         /// <summary />
         public virtual Task DeleteVolumeAsync(string volumeId, CancellationToken cancellationToken = default(CancellationToken))
         {
@@ -1152,6 +1206,168 @@ protected ComputeApiBuilder(IServiceType serviceType, IAuthenticationProvider au
             return Endpoint.PrepareDeleteResourceRequest($"os-volumes/{volumeId}", cancellationToken);
         }
 
+        /// <summary />
+        public virtual Task DeleteVolumeSnapshotAsync(string snapshotId, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return BuildDeleteVolumeSnapshotRequest(snapshotId, cancellationToken).SendAsync();
+        }
+
+        /// <summary />
+        public virtual Task<PreparedRequest> BuildDeleteVolumeSnapshotRequest(string snapshotId, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            if (snapshotId == null)
+                throw new ArgumentNullException("snapshotId");
+
+            return Endpoint.PrepareDeleteResourceRequest($"os-snapshots/{snapshotId}", cancellationToken);
+        }
+
+        /// <summary>
+        /// Waits for the volume to reach the specified status.
+        /// </summary>
+        /// <param name="volumeId">The volume identifier.</param>
+        /// <param name="status">The status to wait for.</param>
+        /// <param name="refreshDelay">The amount of time to wait between requests.</param>
+        /// <param name="timeout">The amount of time to wait before throwing a <see cref="TimeoutException"/>.</param>
+        /// <param name="progress">The progress callback.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <exception cref="TimeoutException">If the <paramref name="timeout"/> value is reached.</exception>
+        /// <exception cref="FlurlHttpException">If the API call returns a bad <see cref="HttpStatusCode"/>.</exception>
+        public async Task<TVolume> WaitForVolumeStatusAsync<TVolume, TStatus>(string volumeId, TStatus status, TimeSpan? refreshDelay = null, TimeSpan? timeout = null, IProgress<bool> progress = null, CancellationToken cancellationToken = default(CancellationToken))
+            where TVolume : IServiceResource
+            where TStatus : ResourceStatus
+        {
+            if(volumeId == null)
+                throw new ArgumentNullException("volumeId");
+
+            if(status == null)
+                throw new ArgumentNullException("status");
+
+            Func<Task<TVolume>> getVolume = async () => await GetVolumeAsync<TVolume>(volumeId, cancellationToken);
+            return await Endpoint.WaitForStatusAsync(volumeId, status, getVolume, refreshDelay, timeout, progress, cancellationToken)
+                .PropogateOwner(this);
+        }
+
+        /// <summary>
+        /// Waits for the volume snapshot to reach the specified status.
+        /// </summary>
+        /// <param name="snapshotId">The snapshot identifier.</param>
+        /// <param name="status">The status to wait for.</param>
+        /// <param name="refreshDelay">The amount of time to wait between requests.</param>
+        /// <param name="timeout">The amount of time to wait before throwing a <see cref="TimeoutException"/>.</param>
+        /// <param name="progress">The progress callback.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <exception cref="TimeoutException">If the <paramref name="timeout"/> value is reached.</exception>
+        /// <exception cref="FlurlHttpException">If the API call returns a bad <see cref="HttpStatusCode"/>.</exception>
+        public async Task<TSnapshot> WaitForVolumeSnapshotStatusAsync<TSnapshot, TStatus>(string snapshotId, TStatus status, TimeSpan? refreshDelay = null, TimeSpan? timeout = null, IProgress<bool> progress = null, CancellationToken cancellationToken = default(CancellationToken))
+            where TSnapshot : IServiceResource
+            where TStatus : ResourceStatus
+        {
+            if (snapshotId == null)
+                throw new ArgumentNullException("snapshotId");
+
+            if (status == null)
+                throw new ArgumentNullException("status");
+
+            Func<Task<TSnapshot>> getSnapshot = async () => await GetVolumeSnapshotAsync<TSnapshot>(snapshotId, cancellationToken);
+            return await Endpoint.WaitForStatusAsync(snapshotId, status, getSnapshot, refreshDelay, timeout, progress, cancellationToken)
+                .PropogateOwner(this);
+        }
+
+        /// <summary>
+        /// Waits for the volume to reach the specified status.
+        /// </summary>
+        /// <param name="volumeId">The volume identifier.</param>
+        /// <param name="status">The status to wait for.</param>
+        /// <param name="refreshDelay">The amount of time to wait between requests.</param>
+        /// <param name="timeout">The amount of time to wait before throwing a <see cref="TimeoutException"/>.</param>
+        /// <param name="progress">The progress callback.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <exception cref="TimeoutException">If the <paramref name="timeout"/> value is reached.</exception>
+        /// <exception cref="FlurlHttpException">If the API call returns a bad <see cref="HttpStatusCode"/>.</exception>
+        public async Task<TVolume> WaitForVolumeStatusAsync<TVolume, TStatus>(string volumeId, IEnumerable<TStatus> status, TimeSpan? refreshDelay = null, TimeSpan? timeout = null, IProgress<bool> progress = null, CancellationToken cancellationToken = default(CancellationToken))
+            where TVolume : IServiceResource
+            where TStatus : ResourceStatus
+        {
+            if (volumeId == null)
+                throw new ArgumentNullException("volumeId");
+
+            if (status == null)
+                throw new ArgumentNullException("status");
+
+            Func<Task<TVolume>> getVolume = async () => await GetVolumeAsync<TVolume>(volumeId, cancellationToken);
+            return await Endpoint.WaitForStatusAsync(volumeId, status, getVolume, refreshDelay, timeout, progress, cancellationToken)
+                .PropogateOwner(this);
+        }
+
+        /// <summary>
+        /// Waits for the volume snapshot to reach the specified status.
+        /// </summary>
+        /// <param name="snapshotId">The snapshot identifier.</param>
+        /// <param name="status">The status to wait for.</param>
+        /// <param name="refreshDelay">The amount of time to wait between requests.</param>
+        /// <param name="timeout">The amount of time to wait before throwing a <see cref="TimeoutException"/>.</param>
+        /// <param name="progress">The progress callback.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <exception cref="TimeoutException">If the <paramref name="timeout"/> value is reached.</exception>
+        /// <exception cref="FlurlHttpException">If the API call returns a bad <see cref="HttpStatusCode"/>.</exception>
+        public async Task<TSnapshot> WaitForVolumeSnapshotStatusAsync<TSnapshot, TStatus>(string snapshotId, IEnumerable<TStatus> status, TimeSpan? refreshDelay = null, TimeSpan? timeout = null, IProgress<bool> progress = null, CancellationToken cancellationToken = default(CancellationToken))
+            where TSnapshot : IServiceResource
+            where TStatus : ResourceStatus
+        {
+            if (snapshotId == null)
+                throw new ArgumentNullException("snapshotId");
+
+            if (status == null)
+                throw new ArgumentNullException("status");
+
+            Func<Task<TSnapshot>> getSnapshot = async () => await GetVolumeSnapshotAsync<TSnapshot>(snapshotId, cancellationToken);
+            return await Endpoint.WaitForStatusAsync(snapshotId, status, getSnapshot, refreshDelay, timeout, progress, cancellationToken)
+                .PropogateOwner(this);
+        }
+
+        /// <summary>
+        /// Waits for the volume to be deleted.
+        /// <para>Treats a 404 NotFound exception as confirmation that it is deleted.</para>
+        /// </summary>
+        /// <param name="volumeId">The volume identifier.</param>
+        /// <param name="refreshDelay">The amount of time to wait between requests.</param>
+        /// <param name="timeout">The amount of time to wait before throwing a <see cref="TimeoutException"/>.</param>
+        /// <param name="progress">The progress callback.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <exception cref="TimeoutException">If the <paramref name="timeout"/> value is reached.</exception>
+        /// <exception cref="FlurlHttpException">If the API call returns a bad <see cref="HttpStatusCode"/>.</exception>
+        public Task WaitUntilVolumeIsDeletedAsync<TVolume, TStatus>(string volumeId, TimeSpan? refreshDelay = null, TimeSpan? timeout = null, IProgress<bool> progress = null, CancellationToken cancellationToken = default(CancellationToken))
+            where TVolume : IServiceResource
+            where TStatus : ResourceStatus
+        {
+            if (volumeId == null)
+                throw new ArgumentNullException("volumeId");
+            
+            Func<Task<dynamic>> getVolume = async () => await GetVolumeAsync<TVolume>(volumeId, cancellationToken);
+            return Endpoint.WaitUntilDeletedAsync<TStatus>(volumeId, getVolume, refreshDelay, timeout, progress, cancellationToken);
+        }
+
+        /// <summary>
+        /// Waits for the volume snapshot to be deleted.
+        /// <para>Treats a 404 NotFound exception as confirmation that it is deleted.</para>
+        /// </summary>
+        /// <param name="snapshotId">The snapshot identifier.</param>
+        /// <param name="refreshDelay">The amount of time to wait between requests.</param>
+        /// <param name="timeout">The amount of time to wait before throwing a <see cref="TimeoutException"/>.</param>
+        /// <param name="progress">The progress callback.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <exception cref="TimeoutException">If the <paramref name="timeout"/> value is reached.</exception>
+        /// <exception cref="FlurlHttpException">If the API call returns a bad <see cref="HttpStatusCode"/>.</exception>
+        public Task WaitUntilVolumeSnapshotIsDeletedAsync<TVolume, TStatus>(string snapshotId, TimeSpan? refreshDelay = null, TimeSpan? timeout = null, IProgress<bool> progress = null, CancellationToken cancellationToken = default(CancellationToken))
+            where TVolume : IServiceResource
+            where TStatus : ResourceStatus
+        {
+            if (snapshotId == null)
+                throw new ArgumentNullException("snapshotId");
+
+            Func<Task<dynamic>> getSnapshot = async () => await GetVolumeSnapshotAsync<TVolume>(snapshotId, cancellationToken);
+            return Endpoint.WaitUntilDeletedAsync<TStatus>(snapshotId, getSnapshot, refreshDelay, timeout, progress, cancellationToken);
+        }
         #endregion
 
         #region Compute Service