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