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(); }