public Task DeleteAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
throw new NotImplementedException();
}
public override Task <bool> DeleteIfExistsAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
return(base.DeleteIfExistsAsync(deleteSnapshotsOption, accessCondition, options, operationContext));
}
public virtual Task DeleteAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return AsyncExtensions.TaskFromVoidApm(this.BeginDelete, this.EndDelete, deleteSnapshotsOption, accessCondition, options, operationContext, cancellationToken);
}
public bool DeleteIfExists(DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.BlockBlob, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
bool exists = this.Exists(modifiedOptions, operationContext);
if (!exists)
{
return false;
}
try
{
this.Delete(deleteSnapshotsOption, accessCondition, modifiedOptions, operationContext);
return true;
}
catch (StorageException e)
{
if (e.RequestInformation.HttpStatusCode == (int)HttpStatusCode.NotFound)
{
if ((e.RequestInformation.ExtendedErrorInformation == null) ||
(e.RequestInformation.ExtendedErrorInformation.ErrorCode == BlobErrorCodeStrings.BlobNotFound))
{
return false;
}
else
{
throw;
}
}
else
{
throw;
}
}
}
private void DeleteIfExistsHandler(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, ChainedAsyncResult<bool> chainedResult)
{
lock (chainedResult.CancellationLockerObject)
{
ICancellableAsyncResult savedExistsResult = this.BeginExists(
options,
operationContext,
existsResult =>
{
chainedResult.UpdateCompletedSynchronously(existsResult.CompletedSynchronously);
lock (chainedResult.CancellationLockerObject)
{
chainedResult.CancelDelegate = null;
try
{
bool exists = this.EndExists(existsResult);
if (!exists)
{
chainedResult.Result = false;
chainedResult.OnComplete();
return;
}
ICancellableAsyncResult savedDeleteResult = this.BeginDelete(
deleteSnapshotsOption,
accessCondition,
options,
operationContext,
deleteResult =>
{
chainedResult.UpdateCompletedSynchronously(deleteResult.CompletedSynchronously);
chainedResult.CancelDelegate = null;
try
{
this.EndDelete(deleteResult);
chainedResult.Result = true;
chainedResult.OnComplete();
}
catch (StorageException e)
{
if (e.RequestInformation.HttpStatusCode == (int)HttpStatusCode.NotFound)
{
chainedResult.Result = false;
chainedResult.OnComplete();
}
else
{
chainedResult.OnComplete(e);
}
}
catch (Exception e)
{
chainedResult.OnComplete(e);
}
},
null /* state */);
chainedResult.CancelDelegate = savedDeleteResult.Cancel;
if (chainedResult.CancelRequested)
{
chainedResult.Cancel();
}
}
catch (Exception e)
{
chainedResult.OnComplete(e);
}
}
},
null /* state */);
chainedResult.CancelDelegate = savedExistsResult.Cancel;
if (chainedResult.CancelRequested)
{
chainedResult.Cancel();
}
}
}
private void DeleteIfExistsHandler(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, StorageAsyncResult<bool> storageAsyncResult)
{
ICancellableAsyncResult savedExistsResult = this.BeginExists(
true,
options,
operationContext,
existsResult =>
{
storageAsyncResult.UpdateCompletedSynchronously(existsResult.CompletedSynchronously);
lock (storageAsyncResult.CancellationLockerObject)
{
storageAsyncResult.CancelDelegate = null;
try
{
bool exists = this.EndExists(existsResult);
if (!exists)
{
storageAsyncResult.Result = false;
storageAsyncResult.OnComplete();
return;
}
ICancellableAsyncResult savedDeleteResult = this.BeginDelete(
deleteSnapshotsOption,
accessCondition,
options,
operationContext,
deleteResult =>
{
storageAsyncResult.UpdateCompletedSynchronously(deleteResult.CompletedSynchronously);
storageAsyncResult.CancelDelegate = null;
try
{
this.EndDelete(deleteResult);
storageAsyncResult.Result = true;
storageAsyncResult.OnComplete();
}
catch (StorageException e)
{
if (e.RequestInformation.HttpStatusCode == (int)HttpStatusCode.NotFound)
{
if ((e.RequestInformation.ExtendedErrorInformation == null) ||
(e.RequestInformation.ExtendedErrorInformation.ErrorCode == BlobErrorCodeStrings.BlobNotFound))
{
storageAsyncResult.Result = false;
storageAsyncResult.OnComplete();
}
else
{
storageAsyncResult.OnComplete(e);
}
}
else
{
storageAsyncResult.OnComplete(e);
}
}
catch (Exception e)
{
storageAsyncResult.OnComplete(e);
}
},
null /* state */);
storageAsyncResult.CancelDelegate = savedDeleteResult.Cancel;
if (storageAsyncResult.CancelRequested)
{
storageAsyncResult.Cancel();
}
}
catch (Exception e)
{
storageAsyncResult.OnComplete(e);
}
}
},
null /* state */);
// We do not need to do this inside a lock, as storageAsyncResult is
// not returned to the user yet.
storageAsyncResult.CancelDelegate = savedExistsResult.Cancel;
}
public IAsyncAction DeleteAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.PageBlob, this.ServiceClient);
return AsyncInfo.Run(async (token) => await Executor.ExecuteAsyncNullReturn(
CloudBlobSharedImpl.DeleteBlobImpl(this, this.attributes, deleteSnapshotsOption, accessCondition, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
token));
}
public override Task DeleteAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw exception;
}
public override bool DeleteIfExists(DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
throw exception;
}
private RESTCommand <NullType> DeleteBlobImpl(BlobAttributes attributes, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options)
{
throw new System.NotImplementedException();
}
public override ICancellableAsyncResult BeginDeleteIfExists(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
throw exception;
}
public virtual Task <bool> DeleteIfExistsAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual Task DeleteAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
throw new System.NotImplementedException();
}
public override Task <bool> DeleteIfExistsAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new NotImplementedException();
// return base.DeleteIfExistsAsync(deleteSnapshotsOption, accessCondition, options, operationContext, cancellationToken);
}
public Task<bool> DeleteIfExistsAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public override Task <bool> DeleteIfExistsAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
throw exception;
}
/// <summary>
/// Implements the DeleteBlob method.
/// </summary>
/// <param name="blob">The blob object that is calling this method.</param>
/// <param name="attributes">The blob's attributes.</param>
/// <param name="deleteSnapshotsOption">Whether to only delete the blob, to delete the blob and all snapshots, or to only delete the snapshots.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that deletes the blob.</returns>
internal static RESTCommand<NullType> DeleteBlobImpl(ICloudBlob blob, BlobAttributes attributes, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<NullType> deleteCmd = new RESTCommand<NullType>(blob.ServiceClient.Credentials, attributes.StorageUri);
options.ApplyToStorageCommand(deleteCmd);
deleteCmd.Handler = blob.ServiceClient.AuthenticationHandler;
deleteCmd.BuildClient = HttpClientFactory.BuildHttpClient;
deleteCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => BlobHttpRequestMessageFactory.Delete(uri, serverTimeout, attributes.SnapshotTime, deleteSnapshotsOption, accessCondition, cnt, ctx);
deleteCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, NullType.Value, cmd, ex);
return deleteCmd;
}
public virtual Task DeleteAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return(this.failoverExecutor.ExecuteAsync(x => x.DeleteAsync(deleteSnapshotsOption, accessCondition, options, operationContext, cancellationToken)));
}
/// <summary>
/// Delete azure blob
/// </summary>
/// <param name="blob">ICloudblob object</param>
/// <param name="deleteSnapshotsOption">Delete snapshots option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="operationContext">Operation context</param>
/// <returns>An enumerable collection of icloudblob</returns>
public void DeleteICloudBlob(ICloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
CloudBlobContainer container = blob.Container;
if (!ContainerBlobs.ContainsKey(container.Name))
{
return;
}
else
{
List<ICloudBlob> blobList = ContainerBlobs[container.Name];
foreach (ICloudBlob blobRef in blobList)
{
if (blobRef.Name == blob.Name)
{
blobList.Remove(blobRef);
return;
}
}
}
}
public virtual Task <bool> DeleteIfExistsAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
return(this.failoverExecutor.ExecuteAsync(x => x.DeleteIfExistsAsync(deleteSnapshotsOption, accessCondition, options, operationContext)));
}
/// <summary>
/// Delete azure blob
/// </summary>
/// <param name="blob">ICloudblob object</param>
/// <param name="deleteSnapshotsOption">Delete snapshots option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="operationContext">Operation context</param>
/// <returns>An enumerable collection of icloudblob</returns>
public void DeleteICloudBlob(ICloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
blob.Delete(deleteSnapshotsOption, accessCondition, options, operationContext);
}
/// <summary>
/// Constructs a web request to delete a blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="deleteSnapshotsOption">A set of options indicating whether to delete only blobs, only snapshots, or both.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpWebRequest Delete(Uri uri, int?timeout, DateTimeOffset?snapshot, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, OperationContext operationContext)
{
if ((snapshot != null) && (deleteSnapshotsOption != DeleteSnapshotsOption.None))
{
throw new InvalidOperationException(string.Format(SR.DeleteSnapshotsNotValidError, "deleteSnapshotsOption", "snapshot"));
}
UriQueryBuilder builder = new UriQueryBuilder();
BlobHttpWebRequestFactory.AddSnapshot(builder, snapshot);
HttpWebRequest request = HttpWebRequestFactory.Delete(uri, builder, timeout, operationContext);
switch (deleteSnapshotsOption)
{
case DeleteSnapshotsOption.None:
break; // nop
case DeleteSnapshotsOption.IncludeSnapshots:
request.Headers.Add(
Constants.HeaderConstants.DeleteSnapshotHeader,
Constants.HeaderConstants.IncludeSnapshotsValue);
break;
case DeleteSnapshotsOption.DeleteSnapshotsOnly:
request.Headers.Add(
Constants.HeaderConstants.DeleteSnapshotHeader,
Constants.HeaderConstants.SnapshotsOnlyValue);
break;
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
public Task<bool> DeleteIfExistsAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return AsyncExtensions.TaskFromApm(this.BeginDeleteIfExists, this.EndDeleteIfExists, deleteSnapshotsOption, accessCondition, options, operationContext, cancellationToken);
}
/// <summary>
/// Implements the DeleteBlob method.
/// </summary>
/// <param name="blob">The blob object that is calling this method.</param>
/// <param name="attributes">The blob's attributes.</param>
/// <param name="deleteSnapshotsOption">Whether to only delete the blob, to delete the blob and all snapshots, or to only delete the snapshots.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies additional options for the request.</param>
/// <returns>A <see cref="RESTCommand"/> that deletes the blob.</returns>
internal static RESTCommand <NullType> DeleteBlobImpl(ICloudBlob blob, BlobAttributes attributes, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand <NullType> deleteCmd = new RESTCommand <NullType>(blob.ServiceClient.Credentials, attributes.StorageUri);
options.ApplyToStorageCommand(deleteCmd);
deleteCmd.Handler = blob.ServiceClient.AuthenticationHandler;
deleteCmd.BuildClient = HttpClientFactory.BuildHttpClient;
deleteCmd.BuildRequest = (cmd, uri, builder, cnt, serverTimeout, ctx) => BlobHttpRequestMessageFactory.Delete(uri, serverTimeout, attributes.SnapshotTime, deleteSnapshotsOption, accessCondition, cnt, ctx);
deleteCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, NullType.Value, cmd, ex);
return(deleteCmd);
}
public ICancellableAsyncResult BeginDelete(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.PageBlob, this.ServiceClient);
return Executor.BeginExecuteAsync(
CloudBlobSharedImpl.DeleteBlobImpl(this, this.attributes, deleteSnapshotsOption, accessCondition, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
callback,
state);
}
public static void Delete(this CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
blob.DeleteAsync(deleteSnapshotsOption, accessCondition, options, operationContext).GetAwaiter().GetResult();
}
public virtual Task DeleteAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
return this.DeleteAsync(deleteSnapshotsOption, accessCondition, options, operationContext, CancellationToken.None);
}
public static bool DeleteIfExists(this CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
return(blob.DeleteIfExistsAsync(deleteSnapshotsOption, accessCondition, options, operationContext).GetAwaiter().GetResult());
}
public ICancellableAsyncResult BeginDeleteIfExists(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
throw new NotImplementedException();
}
/// <summary>
/// Return a task that asynchronously delete the specified blob
/// </summary>
/// <param name="blob">ICloudBlob object</param>
/// <param name="deleteSnapshotsOption">Snapshot delete option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="requestOptions">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return a task that asynchronously delete the specified blob</returns>
public Task DeleteICloudBlobAsync(ICloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions requestOptions, OperationContext operationContext, CancellationToken cmdletCancellationToken)
{
return(Task.Factory.StartNew(() => this.DeleteICloudBlob(blob, deleteSnapshotsOption, accessCondition, requestOptions, operationContext)));
}
public bool DeleteIfExists(DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
throw new NotImplementedException();
}
/// <summary>
/// remove the azure blob
/// </summary>
/// <param name="blob">Cloudblob object</param>
/// <param name="isValidBlob">whether the Cloudblob parameter is validated</param>
/// <returns>true if the blob is removed successfully, false if user cancel the remove operation</returns>
internal async Task RemoveAzureBlob(long taskId, IStorageBlobManagement localChannel, CloudBlob blob, bool isValidBlob)
{
if (!isValidBlob)
{
ValidatePipelineCloudBlob(blob);
}
ValidateBlobType(blob);
DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None;
bool retryDeleteSnapshot = false;
if (IsSnapshot(blob))
{
if (deleteSnapshot)
{
throw new ArgumentException(String.Format(Resources.CannotDeleteSnapshotForSnapshot, blob.Name, blob.SnapshotTime));
}
}
else
{
if (deleteSnapshot)
{
deleteSnapshotsOption = DeleteSnapshotsOption.DeleteSnapshotsOnly;
}
else if (force)
{
deleteSnapshotsOption = DeleteSnapshotsOption.IncludeSnapshots;
}
else
{
retryDeleteSnapshot = true;
}
}
try
{
await DeleteCloudAsync(taskId, localChannel, blob, deleteSnapshotsOption);
retryDeleteSnapshot = false;
}
catch (StorageException e)
{
if (e.IsConflictException() && retryDeleteSnapshot)
{
//If x-ms-delete-snapshots is not specified on the request and the blob has associated snapshots, the Blob service returns status code 409 (Conflict).
retryDeleteSnapshot = true;
}
else
{
throw;
}
}
if (retryDeleteSnapshot)
{
string message = string.Format(Resources.ConfirmRemoveBlobWithSnapshot, blob.Name, blob.Container.Name);
if (await OutputStream.ConfirmAsync(message))
{
deleteSnapshotsOption = DeleteSnapshotsOption.IncludeSnapshots;
await DeleteCloudAsync(taskId, localChannel, blob, deleteSnapshotsOption);
}
else
{
string result = String.Format(Resources.RemoveBlobCancelled, blob.Name, blob.Container.Name);
OutputStream.WriteVerbose(taskId, result);
}
}
}
/// <summary>
/// Deletes the blob if it already exists asynchronously.
/// </summary>
/// <param name="cloudBlob">Cloud blob client.</param>
/// <param name="deleteSnapshotsOption">Whether to only delete the blob, to delete the blob and all snapshots, or to only delete the snapshots.</param>
/// <param name="accessCondition">
/// An <see cref="T:Microsoft.WindowsAzure.Storage.AccessCondition" /> object that represents the access conditions for the blob.
/// </param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>
/// <c>true</c> if the blob did not already exist and was created; otherwise <c>false</c>.
/// </returns>
public static Task<bool> DeleteIfExistsAsync(
this ICloudBlob cloudBlob,
DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None,
AccessCondition accessCondition = null,
CancellationToken cancellationToken = default (CancellationToken))
{
ICancellableAsyncResult asyncResult = cloudBlob.BeginDeleteIfExists(deleteSnapshotsOption, accessCondition, null, null, null, null);
CancellationTokenRegistration registration = cancellationToken.Register(p => asyncResult.Cancel(), null);
return Task<bool>.Factory.FromAsync(
asyncResult,
result =>
{
registration.Dispose();
return cloudBlob.EndDeleteIfExists(result);
});
}
internal async Task DeleteCloudAsync(long taskId, IStorageBlobManagement localChannel, CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption)
{
AccessCondition accessCondition = null;
BlobRequestOptions requestOptions = null;
await localChannel.DeleteCloudBlobAsync(blob, deleteSnapshotsOption, accessCondition,
requestOptions, OperationContext, CmdletCancellationToken);
string result = String.Format(Resources.RemoveBlobSuccessfully, blob.Name, blob.Container.Name);
OutputStream.WriteVerbose(taskId, result);
if (PassThru)
{
OutputStream.WriteObject(taskId, true);
}
}
public ICancellableAsyncResult BeginDeleteIfExists(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.Unspecified, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
StorageAsyncResult<bool> storageAsyncResult = new StorageAsyncResult<bool>(callback, state)
{
RequestOptions = modifiedOptions,
OperationContext = operationContext,
};
this.DeleteIfExistsHandler(deleteSnapshotsOption, accessCondition, modifiedOptions, operationContext, storageAsyncResult);
return storageAsyncResult;
}
/// <summary>
/// Delete azure blob
/// </summary>
/// <param name="blob">Cloudblob object</param>
/// <param name="deleteSnapshotsOption">Delete snapshots option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="operationContext">Operation context</param>
/// <returns>An enumerable collection of CloudBlob</returns>
public void DeleteCloudBlob(CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
blob.Delete(deleteSnapshotsOption, accessCondition, options, operationContext);
}
/// <summary>
/// Implements the DeleteBlob method.
/// </summary>
/// <param name="blobAttributes">The attributes.</param>
/// <param name="deleteSnapshotsOption">Whether to only delete the blob, to delete the blob and all snapshots, or to only delete the snapshots.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed. If <c>null</c>, no condition is used.</param>
/// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param>
/// <returns>
/// A <see cref="RESTCommand{T}"/> that deletes the blob.
/// </returns>
private RESTCommand<NullType> DeleteBlobImpl(BlobAttributes blobAttributes, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options)
{
RESTCommand<NullType> deleteCmd = new RESTCommand<NullType>(this.ServiceClient.Credentials, blobAttributes.StorageUri);
options.ApplyToStorageCommand(deleteCmd);
deleteCmd.BuildRequestDelegate = (uri, builder, serverTimeout, useVersionHeader, ctx) => BlobHttpWebRequestFactory.Delete(uri, serverTimeout, blobAttributes.SnapshotTime, deleteSnapshotsOption, accessCondition, useVersionHeader, ctx);
deleteCmd.SignRequest = this.ServiceClient.AuthenticationHandler.SignRequest;
deleteCmd.PreProcessResponse = (cmd, resp, ex, ctx) => HttpResponseParsers.ProcessExpectedStatusCodeNoException(HttpStatusCode.Accepted, resp, NullType.Value, cmd, ex);
return deleteCmd;
}
/// <summary>
/// Return a task that asynchronously delete the specified blob
/// </summary>
/// <param name="blob">CloudBlob object</param>
/// <param name="deleteSnapshotsOption">Snapshot delete option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="requestOptions">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return a task that asynchronously delete the specified blob</returns>
public Task DeleteCloudBlobAsync(CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
return(blob.DeleteAsync(deleteSnapshotsOption, accessCondition, requestOptions, operationContext, cancellationToken));
}
/// <summary>
/// Constructs a web request to delete a blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="deleteSnapshotsOption">A set of options indicating whether to delete only blobs, only snapshots, or both.</param>
/// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpWebRequest Delete(Uri uri, int timeout, DateTime? snapshot, DeleteSnapshotsOption deleteSnapshotsOption, string leaseId)
{
UriQueryBuilder builder = new UriQueryBuilder();
if (snapshot != null && deleteSnapshotsOption != DeleteSnapshotsOption.None)
{
throw new InvalidOperationException(String.Format(SR.DeleteSnapshotsNotValidError, "deleteSnapshotsOption", "snapshot"));
}
BlobRequest.AddSnapshot(builder, snapshot);
var request = Request.Delete(uri, timeout, builder);
Request.AddLeaseId(request, leaseId);
switch (deleteSnapshotsOption)
{
case DeleteSnapshotsOption.None:
break; // nop
case DeleteSnapshotsOption.IncludeSnapshots:
request.Headers.Add(
Constants.HeaderConstants.DeleteSnapshotHeader,
Constants.HeaderConstants.IncludeSnapshotsValue);
break;
case DeleteSnapshotsOption.DeleteSnapshotsOnly:
request.Headers.Add(
Constants.HeaderConstants.DeleteSnapshotHeader,
Constants.HeaderConstants.SnapshotsOnlyValue);
break;
}
return request;
}
public static string ToSerialString(this DeleteSnapshotsOption value) => value switch
{
public IAsyncOperation<bool> DeleteIfExistsAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.PageBlob, this.ServiceClient);
return AsyncInfo.Run(async (token) =>
{
bool exists = await Executor.ExecuteAsync(
CloudBlobSharedImpl.ExistsImpl(this, this.attributes, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
token);
if (!exists)
{
return false;
}
try
{
await Executor.ExecuteAsync(
CloudBlobSharedImpl.DeleteBlobImpl(this, this.attributes, deleteSnapshotsOption, accessCondition, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
token);
return true;
}
catch (StorageException e)
{
if (e.RequestInformation.HttpStatusCode == (int)HttpStatusCode.NotFound)
{
return false;
}
else
{
throw;
}
}
});
}
/// <summary>
/// Constructs a web request to delete a blob.
/// </summary>
/// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
/// <param name="timeout">An integer specifying the server timeout interval.</param>
/// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="deleteSnapshotsOption">A set of options indicating whether to delete only blobs, only snapshots, or both.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
public static HttpWebRequest Delete(Uri uri, int? timeout, DateTimeOffset? snapshot, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, OperationContext operationContext)
{
return BlobHttpWebRequestFactory.Delete(uri, timeout, snapshot, deleteSnapshotsOption, accessCondition, true /* useVersionHeader */, operationContext);
}
/// <summary>
/// Return a task that asynchronously delete the specified blob
/// </summary>
/// <param name="blob">ICloudBlob object</param>
/// <param name="deleteSnapshotsOption">Snapshot delete option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="requestOptions">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return a task that asynchronously delete the specified blob</returns>
public Task DeleteICloudBlobAsync(ICloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions requestOptions, OperationContext operationContext, CancellationToken cancellationToken)
{
return blob.DeleteAsync(deleteSnapshotsOption, accessCondition, requestOptions, operationContext, cancellationToken);
}
/// <summary>
/// Constructs a web request to delete a blob.
/// </summary>
/// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
/// <param name="timeout">An integer specifying the server timeout interval.</param>
/// <param name="snapshot">A <see cref="DateTimeOffset"/> specifying the snapshot timestamp, if the blob is a snapshot.</param>
/// <param name="deleteSnapshotsOption">A set of options indicating whether to delete only blobs, only snapshots, or both.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
/// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
public static HttpWebRequest Delete(Uri uri, int? timeout, DateTimeOffset? snapshot, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
{
if ((snapshot != null) && (deleteSnapshotsOption != DeleteSnapshotsOption.None))
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, SR.DeleteSnapshotsNotValidError, "deleteSnapshotsOption", "snapshot"));
}
UriQueryBuilder builder = new UriQueryBuilder();
BlobHttpWebRequestFactory.AddSnapshot(builder, snapshot);
HttpWebRequest request = HttpWebRequestFactory.Delete(uri, builder, timeout, useVersionHeader, operationContext);
switch (deleteSnapshotsOption)
{
case DeleteSnapshotsOption.None:
break; // nop
case DeleteSnapshotsOption.IncludeSnapshots:
request.Headers.Add(
Constants.HeaderConstants.DeleteSnapshotHeader,
Constants.HeaderConstants.IncludeSnapshotsValue);
break;
case DeleteSnapshotsOption.DeleteSnapshotsOnly:
request.Headers.Add(
Constants.HeaderConstants.DeleteSnapshotHeader,
Constants.HeaderConstants.SnapshotsOnlyValue);
break;
}
request.ApplyAccessCondition(accessCondition);
return request;
}
public Task<bool> DeleteIfExistsAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
return this.DeleteIfExistsAsync(deleteSnapshotsOption, accessCondition, options, operationContext, CancellationToken.None);
}
public IAsyncOperation<bool> DeleteIfExistsAsync(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, this.BlobType, this.ServiceClient);
operationContext = operationContext ?? new OperationContext();
return AsyncInfo.Run(async (token) =>
{
bool exists = await this.ExistsAsync(modifiedOptions, operationContext).AsTask(token);
if (!exists)
{
return false;
}
try
{
await this.DeleteAsync(deleteSnapshotsOption, accessCondition, modifiedOptions, operationContext).AsTask(token);
return true;
}
catch (Exception)
{
if (operationContext.LastResult.HttpStatusCode == (int)HttpStatusCode.NotFound)
{
StorageExtendedErrorInformation extendedInfo = operationContext.LastResult.ExtendedErrorInformation;
if ((extendedInfo == null) ||
(extendedInfo.ErrorCode == BlobErrorCodeStrings.BlobNotFound))
{
return false;
}
else
{
throw;
}
}
else
{
throw;
}
}
});
}
public ICancellableAsyncResult BeginDeleteIfExists(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.PageBlob, this.ServiceClient);
ChainedAsyncResult<bool> chainedResult = new ChainedAsyncResult<bool>(callback, state)
{
RequestOptions = modifiedOptions,
OperationContext = operationContext,
};
this.DeleteIfExistsHandler(deleteSnapshotsOption, accessCondition, options, operationContext, chainedResult);
return chainedResult;
}
/// <summary>
/// Delete azure blob
/// </summary>
/// <param name="blob">Cloudblob object</param>
/// <param name="deleteSnapshotsOption">Delete snapshots option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="operationContext">Operation context</param>
/// <returns>An enumerable collection of CloudBlob</returns>
public void DeleteCloudBlob(CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
CloudBlobContainer container = blob.Container;
if (!this.DoesContainerExist(container, null, null))
{
throw new StorageException(ContainerNotFound);
}
else if (ContainerBlobs.ContainsKey(container.Name))
{
List<CloudBlob> blobList = ContainerBlobs[container.Name];
foreach (CloudBlob blobRef in blobList)
{
if (blobRef.Name == blob.Name)
{
blobList.Remove(blobRef);
return;
}
}
}
throw new StorageException(BlobNotFound);
}
public void Delete(DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.PageBlob, this.ServiceClient);
Executor.ExecuteSync(
CloudBlobSharedImpl.DeleteBlobImpl(this, this.attributes, deleteSnapshotsOption, accessCondition, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext);
}
/// <summary>
/// Return a task that asynchronously delete the specified blob
/// </summary>
/// <param name="blob">CloudBlob object</param>
/// <param name="deleteSnapshotsOption">Snapshot delete option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="requestOptions">Blob request option</param>
/// <param name="operationContext">Operation context</param>
/// <param name="cmdletCancellationToken">Cancellation token</param>
/// <returns>Return a task that asynchronously delete the specified blob</returns>
public Task DeleteCloudBlobAsync(CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions requestOptions, OperationContext operationContext, CancellationToken cmdletCancellationToken)
{
return Task.Factory.StartNew(() => this.DeleteCloudBlob(blob, deleteSnapshotsOption, accessCondition, requestOptions, operationContext));
}
public bool DeleteIfExists(DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
bool exists = this.Exists(options, operationContext);
if (!exists)
{
return false;
}
try
{
this.Delete(deleteSnapshotsOption, accessCondition, options, operationContext);
return true;
}
catch (StorageException storageEx)
{
if (storageEx.RequestInformation.HttpStatusCode == (int)HttpStatusCode.NotFound)
{
return false;
}
else
{
throw;
}
}
}
/// <summary>
/// Delete azure blob
/// </summary>
/// <param name="blob">Cloudblob object</param>
/// <param name="deleteSnapshotsOption">Delete snapshots option</param>
/// <param name="accessCondition">Access condition</param>
/// <param name="operationContext">Operation context</param>
/// <returns>An enumerable collection of CloudBlob</returns>
public void DeleteCloudBlob(CloudBlob blob, DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
Task.Run(() => blob.DeleteAsync(deleteSnapshotsOption, accessCondition, options, operationContext)).Wait();
}
