public ICancellableAsyncResult BeginOpenRead(AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { StorageAsyncResult<Stream> storageAsyncResult = new StorageAsyncResult<Stream>(callback, state); ICancellableAsyncResult result = this.BeginFetchAttributes( accessCondition, options, operationContext, ar => { try { this.EndFetchAttributes(ar); storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag); BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, this.BlobType, this.ServiceClient, false); storageAsyncResult.Result = new BlobReadStream(this, streamAccessCondition, modifiedOptions, operationContext); storageAsyncResult.OnComplete(); } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null /* state */); storageAsyncResult.CancelDelegate = result.Cancel; return storageAsyncResult; }
private void WriteStreamCallback(IAsyncResult ar) { StorageAsyncResult <NullType> storageAsyncResult = (StorageAsyncResult <NullType>)ar.AsyncState; storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); Exception endException = null; try { this.wrappedStream.EndWrite(ar); this.position += (int)storageAsyncResult.OperationState; } catch (Exception e) { endException = e; } storageAsyncResult.OnComplete(endException); }
private void WriteRange(Stream rangeData, long offset, string contentMD5, StorageAsyncResult <NullType> asyncResult) { this.noPendingWritesEvent.Increment(); this.parallelOperationSemaphore.WaitAsync(calledSynchronously => { try { ICancellableAsyncResult result = this.file.BeginWriteRange( rangeData, offset, contentMD5, this.accessCondition, this.options, this.operationContext, this.WriteRangeCallback, null /* state */); if (asyncResult != null) { // We do not need to do this inside a lock, as asyncResult is // not returned to the user yet. asyncResult.CancelDelegate = result.Cancel; } } catch (Exception e) { this.lastException = e; this.noPendingWritesEvent.Decrement(); this.parallelOperationSemaphore.Release(); } finally { if (asyncResult != null) { asyncResult.UpdateCompletedSynchronously(calledSynchronously); asyncResult.OnComplete(this.lastException); } } }); }
private void DownloadRangeToStreamCallback(IAsyncResult ar) { StorageAsyncResult <int> storageAsyncResult = (StorageAsyncResult <int>)ar.AsyncState; storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { this.blob.EndDownloadRangeToStream(ar); ArraySegment <byte> bufferSegment = (ArraySegment <byte>)storageAsyncResult.OperationState; this.internalBuffer.Seek(0, SeekOrigin.Begin); storageAsyncResult.Result = this.ConsumeBuffer(bufferSegment.Array, bufferSegment.Offset, bufferSegment.Count); } catch (Exception e) { this.lastException = e; } storageAsyncResult.OnComplete(this.lastException); }
private void WriteBlock(Stream blockData, string blockId, string blockMD5, StorageAsyncResult <NullType> asyncResult) { this.noPendingWritesEvent.Increment(); this.parallelOperationSemaphore.WaitAsync(calledSynchronously => { try { ICancellableAsyncResult result = this.blockBlob.BeginPutBlock( blockId, blockData, blockMD5, this.accessCondition, this.options, this.operationContext, this.PutBlockCallback, null /* state */); if (asyncResult != null) { // We do not need to do this inside a lock, as asyncResult is // not returned to the user yet. asyncResult.CancelDelegate = result.Cancel; } } catch (Exception e) { this.lastException = e; } finally { if (asyncResult != null) { asyncResult.UpdateCompletedSynchronously(calledSynchronously); asyncResult.OnComplete(this.lastException); } } }); }
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state) { StorageAsyncResult<NullType> result = new StorageAsyncResult<NullType>(callback, state); if (this.completeSynchronously) { result.UpdateCompletedSynchronously(this.completeSynchronously); try { this.Write(buffer, offset, count); result.OnComplete(); } catch (Exception e) { result.OnComplete(e); } } else { ThreadPool.QueueUserWorkItem(_ => { result.UpdateCompletedSynchronously(this.completeSynchronously); try { this.Write(buffer, offset, count); result.OnComplete(); } catch (Exception e) { result.OnComplete(e); } }, null); } return result; }
private void WriteRange(Stream rangeData, long offset, string contentMD5, StorageAsyncResult<NullType> asyncResult) { this.noPendingWritesEvent.Increment(); this.parallelOperationSemaphore.WaitAsync(calledSynchronously => { try { ICancellableAsyncResult result = this.file.BeginWriteRange( rangeData, offset, contentMD5, this.accessCondition, this.options, this.operationContext, this.WriteRangeCallback, null /* state */); if (asyncResult != null) { // We do not need to do this inside a lock, as asyncResult is // not returned to the user yet. asyncResult.CancelDelegate = result.Cancel; } } catch (Exception e) { this.lastException = e; } finally { if (asyncResult != null) { asyncResult.UpdateCompletedSynchronously(calledSynchronously); asyncResult.OnComplete(this.lastException); } } }); }
/// <summary> /// Starts an asynchronous AppendBlock operation as soon as the parallel /// operation semaphore becomes available. Since parallelism is always set /// to 1 for append blobs, appendblock operations are called serially. /// </summary> /// <param name="blockData">Data to be uploaded.</param> /// <param name="offset">Offset within the append blob to be used to set the append offset conditional header.</param> /// <param name="blockMD5">MD5 hash of the data to be uploaded.</param> /// <param name="asyncResult">The reference to the pending asynchronous request to finish.</param> private void WriteAppendBlock(Stream blockData, long offset, string blockMD5, StorageAsyncResult<NullType> asyncResult) { this.noPendingWritesEvent.Increment(); this.parallelOperationSemaphore.WaitAsync(calledSynchronously => { try { this.accessCondition.IfAppendPositionEqual = offset; int previousResultsCount = this.operationContext.RequestResults.Count; ICancellableAsyncResult result = this.appendBlob.BeginAppendBlock( blockData, blockMD5, this.accessCondition, this.options, this.operationContext, this.AppendBlockCallback, previousResultsCount /* state */); if (asyncResult != null) { // We do not need to do this inside a lock, as asyncResult is // not returned to the user yet. asyncResult.CancelDelegate = result.Cancel; } } catch (Exception e) { this.lastException = e; this.noPendingWritesEvent.Decrement(); this.parallelOperationSemaphore.Release(); } finally { if (asyncResult != null) { asyncResult.UpdateCompletedSynchronously(calledSynchronously); asyncResult.OnComplete(this.lastException); } } }); }
private void UploadFromStreamHandler(Stream source, long? length, string contentMD5, AccessCondition accessCondition, OperationContext operationContext, BlobRequestOptions options, StorageAsyncResult<NullType> storageAsyncResult) { ICancellableAsyncResult result = Executor.BeginExecuteAsync( this.PutBlobImpl(source, length, contentMD5, accessCondition, options), options.RetryPolicy, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { Executor.EndExecuteAsync<NullType>(ar); storageAsyncResult.OnComplete(); } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null /* asyncState */); storageAsyncResult.CancelDelegate = result.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } }
private void PutBlockHandler(string blockId, Stream blockData, string contentMD5, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, StorageAsyncResult<NullType> storageAsyncResult) { lock (storageAsyncResult.CancellationLockerObject) { ICancellableAsyncResult result = Executor.BeginExecuteAsync( this.PutBlockImpl(blockData, blockId, contentMD5, accessCondition, options), options.RetryPolicy, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { Executor.EndExecuteAsync<NullType>(ar); storageAsyncResult.OnComplete(); } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null /* asyncState */); storageAsyncResult.CancelDelegate = result.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } } }
private void DeleteIfExistsHandler(DeleteSnapshotsOption deleteSnapshotsOption, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, StorageAsyncResult<bool> storageAsyncResult) { lock (storageAsyncResult.CancellationLockerObject) { ICancellableAsyncResult savedExistsResult = this.BeginExists( 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 */); storageAsyncResult.CancelDelegate = savedExistsResult.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } } }
internal ICancellableAsyncResult BeginUploadFromStreamHelper(Stream source, long? length, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { CommonUtility.AssertNotNull("source", source); if (!source.CanSeek) { throw new InvalidOperationException(); } if (length.HasValue) { CommonUtility.AssertInBounds("length", (long)length, 1, source.Length - source.Position); } else { length = source.Length - source.Position; } if ((length % Constants.PageSize) != 0) { throw new ArgumentException(SR.InvalidPageSize, "source"); } this.attributes.AssertNoSnapshot(); BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.PageBlob, this.ServiceClient); ExecutionState<NullType> tempExecutionState = CommonUtility.CreateTemporaryExecutionState(modifiedOptions); StorageAsyncResult<NullType> storageAsyncResult = new StorageAsyncResult<NullType>(callback, state); ICancellableAsyncResult result = this.BeginOpenWrite( length, accessCondition, modifiedOptions, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); lock (storageAsyncResult.CancellationLockerObject) { storageAsyncResult.CancelDelegate = null; try { CloudBlobStream blobStream = this.EndOpenWrite(ar); storageAsyncResult.OperationState = blobStream; source.WriteToAsync( blobStream, length, null /* maxLength */, false, tempExecutionState, null /* streamCopyState */, completedState => { storageAsyncResult.UpdateCompletedSynchronously(completedState.CompletedSynchronously); if (completedState.ExceptionRef != null) { storageAsyncResult.OnComplete(completedState.ExceptionRef); } else { try { lock (storageAsyncResult.CancellationLockerObject) { storageAsyncResult.CancelDelegate = null; ICancellableAsyncResult commitResult = blobStream.BeginCommit( CloudBlob.BlobOutputStreamCommitCallback, storageAsyncResult); storageAsyncResult.CancelDelegate = commitResult.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } } } catch (Exception e) { storageAsyncResult.OnComplete(e); } } }); storageAsyncResult.CancelDelegate = tempExecutionState.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 = result.Cancel; return storageAsyncResult; }
private void DeleteIfExistsHandler(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, StorageAsyncResult<bool> storageAsyncResult) { ICancellableAsyncResult savedExistsResult = this.BeginExists( 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; } } catch (Exception e) { storageAsyncResult.OnComplete(e); return; } ICancellableAsyncResult savedDeleteResult = this.BeginDelete( 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) { storageAsyncResult.Result = false; storageAsyncResult.OnComplete(); } else { storageAsyncResult.OnComplete(e); } } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null); storageAsyncResult.CancelDelegate = savedDeleteResult.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } } }, null); // We do not need to do this inside a lock, as storageAsyncResult is // not returned to the user yet. storageAsyncResult.CancelDelegate = savedExistsResult.Cancel; }
private void CreateIfNotExistsHandler(FileRequestOptions options, OperationContext operationContext, StorageAsyncResult<bool> storageAsyncResult) { ICancellableAsyncResult savedExistsResult = this.BeginExists( 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; } } catch (Exception e) { storageAsyncResult.OnComplete(e); return; } ICancellableAsyncResult savedCreateResult = this.BeginCreate( options, operationContext, createResult => { storageAsyncResult.UpdateCompletedSynchronously(createResult.CompletedSynchronously); storageAsyncResult.CancelDelegate = null; try { this.EndCreate(createResult); storageAsyncResult.Result = true; storageAsyncResult.OnComplete(); } catch (StorageException e) { if ((e.RequestInformation.ExtendedErrorInformation != null) && (e.RequestInformation.ExtendedErrorInformation.ErrorCode == FileErrorCodeStrings.ResourceAlreadyExists)) { storageAsyncResult.Result = false; storageAsyncResult.OnComplete(); } else { storageAsyncResult.OnComplete(e); } } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null); storageAsyncResult.CancelDelegate = savedCreateResult.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } } }, null); // We do not need to do this inside a lock, as storageAsyncResult is // not returned to the user yet. storageAsyncResult.CancelDelegate = savedExistsResult.Cancel; }
private static void ContinueAsyncOperation(StorageAsyncResult<NullType> storageAsyncResult, IAsyncResult result, Action actionToTakeInTheLock) { storageAsyncResult.UpdateCompletedSynchronously(result.CompletedSynchronously); try { lock (storageAsyncResult.CancellationLockerObject) { storageAsyncResult.CancelDelegate = null; actionToTakeInTheLock(); } } catch (Exception e) { storageAsyncResult.OnComplete(e); } }
public ICancellableAsyncResult BeginOpenWrite(long? size, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { this.attributes.AssertNoSnapshot(); bool createNew = size.HasValue; BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, this.BlobType, this.ServiceClient, false); StorageAsyncResult<CloudBlobStream> storageAsyncResult = new StorageAsyncResult<CloudBlobStream>(callback, state); ICancellableAsyncResult result; modifiedOptions.AssertPolicyIfRequired(); if (createNew) { #if !(WINDOWS_RT || ASPNET_K || PORTABLE) ICryptoTransform transform = null; if (options != null && options.EncryptionPolicy != null) { #if WINDOWS_PHONE throw new InvalidOperationException(SR.EncryptionNotSupportedForPageBlobsOnPhone); #else transform = options.EncryptionPolicy.CreateAndSetEncryptionContext(this.Metadata, true /* noPadding */); #endif } #endif result = this.BeginCreate( size.Value, accessCondition, options, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { this.EndCreate(ar); if (accessCondition != null) { accessCondition = AccessCondition.GenerateLeaseCondition(accessCondition.LeaseId); } #if !(WINDOWS_RT || ASPNET_K || PORTABLE) if (modifiedOptions.EncryptionPolicy != null) { storageAsyncResult.Result = new BlobEncryptedWriteStream(this, this.Properties.Length, createNew, accessCondition, modifiedOptions, operationContext, transform); } else #endif { storageAsyncResult.Result = new BlobWriteStream(this, this.Properties.Length, createNew, accessCondition, modifiedOptions, operationContext); } storageAsyncResult.OnComplete(); } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null /* state */); } else { if (modifiedOptions.StoreBlobContentMD5.Value) { throw new ArgumentException(SR.MD5NotPossible); } #if !(WINDOWS_RT || ASPNET_K || PORTABLE) if (modifiedOptions.EncryptionPolicy != null) { throw new ArgumentException(SR.EncryptionNotSupportedForExistingBlobs); } #endif result = this.BeginFetchAttributes( accessCondition, options, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { this.EndFetchAttributes(ar); if (accessCondition != null) { accessCondition = AccessCondition.GenerateLeaseCondition(accessCondition.LeaseId); } storageAsyncResult.Result = new BlobWriteStream(this, this.Properties.Length, createNew, accessCondition, modifiedOptions, operationContext); storageAsyncResult.OnComplete(); } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null /* state */); } storageAsyncResult.CancelDelegate = result.Cancel; return storageAsyncResult; }
public ICancellableAsyncResult BeginOpenWrite(long? size, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { this.attributes.AssertNoSnapshot(); bool createNew = size.HasValue; BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, this.BlobType, this.ServiceClient, false); StorageAsyncResult<CloudBlobStream> storageAsyncResult = new StorageAsyncResult<CloudBlobStream>(callback, state); ICancellableAsyncResult result; if (createNew) { result = this.BeginCreate( size.Value, accessCondition, options, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { this.EndCreate(ar); if (accessCondition != null) { accessCondition = AccessCondition.GenerateLeaseCondition(accessCondition.LeaseId); } storageAsyncResult.Result = new BlobWriteStream(this, size.Value, createNew, accessCondition, modifiedOptions, operationContext); storageAsyncResult.OnComplete(); } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null /* state */); } else { if (modifiedOptions.StoreBlobContentMD5.Value) { throw new ArgumentException(SR.MD5NotPossible); } result = this.BeginFetchAttributes( accessCondition, options, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { this.EndFetchAttributes(ar); if (accessCondition != null) { accessCondition = AccessCondition.GenerateLeaseCondition(accessCondition.LeaseId); } storageAsyncResult.Result = new BlobWriteStream(this, this.Properties.Length, createNew, accessCondition, modifiedOptions, operationContext); storageAsyncResult.OnComplete(); } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null /* state */); } storageAsyncResult.CancelDelegate = result.Cancel; return storageAsyncResult; }
/// <summary> /// Begins an asynchronous operation to open a stream for writing to the blob. /// </summary> /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the blob. If <c>null</c>, no condition is used.</param> /// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies any additional options for the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="ICancellableAsyncResult"/> that references the asynchronous operation.</returns> public ICancellableAsyncResult BeginOpenWrite(AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { this.attributes.AssertNoSnapshot(); StorageAsyncResult<CloudBlobStream> storageAsyncResult = new StorageAsyncResult<CloudBlobStream>(callback, state); BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, this.BlobType, this.ServiceClient, false); if ((accessCondition != null) && accessCondition.IsConditional) { ICancellableAsyncResult result = this.BeginFetchAttributes( accessCondition, options, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { this.EndFetchAttributes(ar); } catch (StorageException e) { if ((e.RequestInformation != null) && (e.RequestInformation.HttpStatusCode == (int)HttpStatusCode.NotFound) && string.IsNullOrEmpty(accessCondition.IfMatchETag)) { // If we got a 404 and the condition was not an If-Match, // we should continue with the operation. } else { storageAsyncResult.OnComplete(e); return; } } catch (Exception e) { storageAsyncResult.OnComplete(e); return; } storageAsyncResult.Result = new BlobWriteStream(this, accessCondition, modifiedOptions, operationContext); storageAsyncResult.OnComplete(); }, null /* state */); storageAsyncResult.CancelDelegate = result.Cancel; } else { storageAsyncResult.Result = new BlobWriteStream(this, accessCondition, modifiedOptions, operationContext); storageAsyncResult.OnComplete(); } return storageAsyncResult; }
private void CommitFlushCallback(IAsyncResult ar) { StorageAsyncResult <NullType> storageAsyncResult = (StorageAsyncResult <NullType>)ar.AsyncState; storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); this.committed = true; lock (storageAsyncResult.CancellationLockerObject) { storageAsyncResult.CancelDelegate = null; try { this.EndFlush(ar); if (this.blockBlob != null) { if (this.blobMD5 != null) { this.blockBlob.Properties.ContentMD5 = this.blobMD5.ComputeHash(); } ICancellableAsyncResult result = this.blockBlob.BeginPutBlockList( this.blockList, this.accessCondition, this.options, this.operationContext, this.PutBlockListCallback, storageAsyncResult); storageAsyncResult.CancelDelegate = result.Cancel; } else { if (this.blobMD5 != null) { this.Blob.Properties.ContentMD5 = this.blobMD5.ComputeHash(); ICancellableAsyncResult result = this.Blob.BeginSetProperties( this.accessCondition, this.options, this.operationContext, this.SetPropertiesCallback, storageAsyncResult); storageAsyncResult.CancelDelegate = result.Cancel; } else { storageAsyncResult.OnComplete(); } } if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } } catch (Exception e) { this.lastException = e; storageAsyncResult.OnComplete(e); } } }
public ICancellableAsyncResult BeginPutBlock(string blockId, Stream blockData, string contentMD5, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { CommonUtility.AssertNotNull("blockData", blockData); BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.BlockBlob, this.ServiceClient); bool requiresContentMD5 = (contentMD5 == null) && modifiedOptions.UseTransactionalMD5.Value; operationContext = operationContext ?? new OperationContext(); StorageAsyncResult<NullType> storageAsyncResult = new StorageAsyncResult<NullType>(callback, state); if (blockData.CanSeek && !requiresContentMD5) { this.PutBlockHandler(blockId, blockData, contentMD5, accessCondition, modifiedOptions, operationContext, storageAsyncResult); } else { ExecutionState<NullType> tempExecutionState = CommonUtility.CreateTemporaryExecutionState(modifiedOptions); storageAsyncResult.CancelDelegate = tempExecutionState.Cancel; Stream seekableStream; Stream writeToStream; if (blockData.CanSeek) { seekableStream = blockData; writeToStream = Stream.Null; } else { seekableStream = new MultiBufferMemoryStream(this.ServiceClient.BufferManager); writeToStream = seekableStream; } long startPosition = seekableStream.Position; StreamDescriptor streamCopyState = new StreamDescriptor(); blockData.WriteToAsync( writeToStream, null /* copyLength */, Constants.MaxBlockSize, requiresContentMD5, tempExecutionState, streamCopyState, completedState => { storageAsyncResult.UpdateCompletedSynchronously(completedState.CompletedSynchronously); if (completedState.ExceptionRef != null) { storageAsyncResult.OnComplete(completedState.ExceptionRef); } else { try { if (requiresContentMD5) { contentMD5 = streamCopyState.Md5; } seekableStream.Position = startPosition; this.PutBlockHandler(blockId, seekableStream, contentMD5, accessCondition, modifiedOptions, operationContext, storageAsyncResult); } catch (Exception e) { storageAsyncResult.OnComplete(e); } } }); } return storageAsyncResult; }
public virtual ICancellableAsyncResult BeginOpenWrite(bool createNew, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { this.attributes.AssertNoSnapshot(); BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, this.BlobType, this.ServiceClient, false); StorageAsyncResult<CloudBlobStream> storageAsyncResult = new StorageAsyncResult<CloudBlobStream>(callback, state); ICancellableAsyncResult result; #if !(WINDOWS_RT || ASPNET_K || PORTABLE) ICryptoTransform transform = null; #endif if (createNew) { #if !(WINDOWS_RT || ASPNET_K || PORTABLE) if (options != null && options.EncryptionPolicy != null) { transform = options.EncryptionPolicy.CreateAndSetEncryptionContext(this.Metadata, false /* noPadding */); } #endif result = this.BeginCreateOrReplace( accessCondition, options, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { this.EndCreateOrReplace(ar); if (accessCondition != null) { accessCondition = new AccessCondition() { LeaseId = accessCondition.LeaseId, IfAppendPositionEqual = accessCondition.IfAppendPositionEqual, IfMaxSizeLessThanOrEqual = accessCondition.IfMaxSizeLessThanOrEqual }; } #if !(WINDOWS_RT || ASPNET_K || PORTABLE) if (modifiedOptions.EncryptionPolicy != null) { storageAsyncResult.Result = new BlobEncryptedWriteStream(this, accessCondition, modifiedOptions, operationContext, transform); } else #endif { storageAsyncResult.Result = new BlobWriteStream(this, accessCondition, modifiedOptions, operationContext); } storageAsyncResult.OnComplete(); } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null /* state */); } else { if (modifiedOptions.StoreBlobContentMD5.Value) { throw new ArgumentException(SR.MD5NotPossible); } #if !(WINDOWS_RT || ASPNET_K || PORTABLE) if (modifiedOptions.EncryptionPolicy != null) { throw new ArgumentException(SR.EncryptionNotSupportedForExistingBlobs); } #endif // Although we don't need any properties from the service, we should make this call in order to honor the user specified conditional headers // while opening an existing stream and to get the append position for an existing blob if user didn't specify one. result = this.BeginFetchAttributes( accessCondition, options, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { this.EndFetchAttributes(ar); if (accessCondition != null) { accessCondition = new AccessCondition() { LeaseId = accessCondition.LeaseId, IfAppendPositionEqual = accessCondition.IfAppendPositionEqual }; } storageAsyncResult.Result = new BlobWriteStream(this, accessCondition, modifiedOptions, operationContext); storageAsyncResult.OnComplete(); } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null /* state */); } storageAsyncResult.CancelDelegate = result.Cancel; return storageAsyncResult; }
internal ICancellableAsyncResult BeginUploadFromStreamHelper(Stream source, long? length, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { CommonUtility.AssertNotNull("source", source); if (length.HasValue) { CommonUtility.AssertInBounds("length", length.Value, 1); if (source.CanSeek && length > source.Length - source.Position) { throw new ArgumentOutOfRangeException("length", SR.StreamLengthShortError); } } this.attributes.AssertNoSnapshot(); BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.BlockBlob, this.ServiceClient); ExecutionState<NullType> tempExecutionState = CommonUtility.CreateTemporaryExecutionState(modifiedOptions); StorageAsyncResult<NullType> storageAsyncResult = new StorageAsyncResult<NullType>(callback, state); bool lessThanSingleBlobThreshold = source.CanSeek && (length ?? source.Length - source.Position) <= this.ServiceClient.SingleBlobUploadThresholdInBytes; if (this.ServiceClient.ParallelOperationThreadCount == 1 && lessThanSingleBlobThreshold) { if (modifiedOptions.StoreBlobContentMD5.Value) { long startPosition = source.Position; StreamDescriptor streamCopyState = new StreamDescriptor(); source.WriteToAsync( Stream.Null, length, null /* maxLength */, true, tempExecutionState, streamCopyState, completedState => { storageAsyncResult.UpdateCompletedSynchronously(completedState.CompletedSynchronously); try { lock (storageAsyncResult.CancellationLockerObject) { storageAsyncResult.CancelDelegate = null; if (completedState.ExceptionRef != null) { storageAsyncResult.OnComplete(completedState.ExceptionRef); } else { source.Position = startPosition; this.UploadFromStreamHandler( source, length, streamCopyState.Md5, accessCondition, operationContext, modifiedOptions, storageAsyncResult); } } } catch (Exception e) { storageAsyncResult.OnComplete(e); } }); // We do not need to do this inside a lock, as storageAsyncResult is // not returned to the user yet. storageAsyncResult.CancelDelegate = tempExecutionState.Cancel; } else { if (modifiedOptions.UseTransactionalMD5.Value) { throw new ArgumentException(SR.PutBlobNeedsStoreBlobContentMD5, "options"); } this.UploadFromStreamHandler( source, length, null /* contentMD5 */, accessCondition, operationContext, modifiedOptions, storageAsyncResult); } } else { ICancellableAsyncResult result = this.BeginOpenWrite( accessCondition, modifiedOptions, operationContext, ar => { storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously); lock (storageAsyncResult.CancellationLockerObject) { storageAsyncResult.CancelDelegate = null; try { CloudBlobStream blobStream = this.EndOpenWrite(ar); storageAsyncResult.OperationState = blobStream; source.WriteToAsync( blobStream, length, null /* maxLength */, false, tempExecutionState, null /* streamCopyState */, completedState => { storageAsyncResult.UpdateCompletedSynchronously(completedState.CompletedSynchronously); if (completedState.ExceptionRef != null) { storageAsyncResult.OnComplete(completedState.ExceptionRef); } else { try { lock (storageAsyncResult.CancellationLockerObject) { storageAsyncResult.CancelDelegate = null; ICancellableAsyncResult commitResult = blobStream.BeginCommit( CloudBlobSharedImpl.BlobOutputStreamCommitCallback, storageAsyncResult); storageAsyncResult.CancelDelegate = commitResult.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } } } catch (Exception e) { storageAsyncResult.OnComplete(e); } } }); storageAsyncResult.CancelDelegate = tempExecutionState.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 = result.Cancel; } return storageAsyncResult; }
private void CreateIfNotExistsHandler(BlobContainerPublicAccessType accessType, 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 savedCreateResult = this.BeginCreate( accessType, options, operationContext, createResult => { storageAsyncResult.UpdateCompletedSynchronously(createResult.CompletedSynchronously); storageAsyncResult.CancelDelegate = null; try { this.EndCreate(createResult); storageAsyncResult.Result = true; storageAsyncResult.OnComplete(); } catch (StorageException e) { if (e.RequestInformation.HttpStatusCode == (int)HttpStatusCode.Conflict) { if ((e.RequestInformation.ExtendedErrorInformation == null) || (e.RequestInformation.ExtendedErrorInformation.ErrorCode == BlobErrorCodeStrings.ContainerAlreadyExists)) { storageAsyncResult.Result = false; storageAsyncResult.OnComplete(); } else { storageAsyncResult.OnComplete(e); } } else { storageAsyncResult.OnComplete(e); } } catch (Exception e) { storageAsyncResult.OnComplete(e); } }, null /* state */); storageAsyncResult.CancelDelegate = savedCreateResult.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 ICancellableAsyncResult BeginListBlobsSegmented(string prefix, bool useFlatBlobListing, BlobListingDetails blobListingDetails, int? maxResults, BlobContinuationToken currentToken, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { string containerName; string listingPrefix; CloudBlobClient.ParseUserPrefix(prefix, out containerName, out listingPrefix); CloudBlobContainer container = this.GetContainerReference(containerName); StorageAsyncResult<BlobResultSegment> result = new StorageAsyncResult<BlobResultSegment>(callback, state); ICancellableAsyncResult asyncResult = container.BeginListBlobsSegmented( listingPrefix, useFlatBlobListing, blobListingDetails, maxResults, currentToken, options, operationContext, ar => { result.UpdateCompletedSynchronously(ar.CompletedSynchronously); try { result.Result = container.EndListBlobsSegmented(ar); result.OnComplete(); } catch (Exception e) { result.OnComplete(e); } }, null /* state */); result.CancelDelegate = asyncResult.Cancel; return result; }
private void WriteBlock(Stream blockData, string blockId, string blockMD5, StorageAsyncResult<NullType> asyncResult) { this.noPendingWritesEvent.Increment(); this.parallelOperationSemaphore.WaitAsync(calledSynchronously => { try { ICancellableAsyncResult result = this.blockBlob.BeginPutBlock( blockId, blockData, blockMD5, this.accessCondition, this.options, this.operationContext, this.PutBlockCallback, null /* state */); if (asyncResult != null) { // We do not need to do this inside a lock, as asyncResult is // not returned to the user yet. asyncResult.CancelDelegate = result.Cancel; } } catch (Exception e) { this.lastException = e; this.noPendingWritesEvent.Decrement(); this.parallelOperationSemaphore.Release(); } finally { if (asyncResult != null) { asyncResult.UpdateCompletedSynchronously(calledSynchronously); asyncResult.OnComplete(this.lastException); } } }); }