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.fileMD5 != null)
{
this.file.Properties.ContentMD5 = this.fileMD5.ComputeHash();
ICancellableAsyncResult result = this.file.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);
}
}
}
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();
}
}
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 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;
}
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 = CloudBlockBlob.IsLessThanSingleBlobThreshold(source, length, modifiedOptions, false);
modifiedOptions.AssertPolicyIfRequired();
if (modifiedOptions.ParallelOperationThreadCount.Value == 1 && lessThanSingleBlobThreshold)
{
// Because we may or may not want to calculate the MD5, and we may or may not want to encrypt, rather than have four branching code
// paths, here we have an action that we will run, which continually gets added to, depending on which operations we need to do.
// The confusing part is that we have to build it from the bottom up.
string md5 = null;
Stream sourceStream = source;
Action actionToRun = null;
Action uploadAction = () =>
{
if (md5 == null && modifiedOptions.UseTransactionalMD5.Value)
{
throw new ArgumentException(SR.PutBlobNeedsStoreBlobContentMD5, "options");
}
this.UploadFromStreamHandler(
sourceStream,
length,
md5,
accessCondition,
operationContext,
modifiedOptions,
storageAsyncResult);
};
actionToRun = uploadAction;
if (modifiedOptions.StoreBlobContentMD5.Value)
{
Action<Action> calculateMD5 = (continuation) =>
{
long startPosition = sourceStream.Position;
StreamDescriptor streamCopyState = new StreamDescriptor();
sourceStream.WriteToAsync(
Stream.Null,
length,
null /* maxLength */,
true,
tempExecutionState,
streamCopyState,
completedState =>
{
ContinueAsyncOperation(storageAsyncResult, completedState, () =>
{
if (completedState.ExceptionRef != null)
{
storageAsyncResult.OnComplete(completedState.ExceptionRef);
}
else
{
sourceStream.Position = startPosition;
md5 = streamCopyState.Md5;
continuation();
}
});
});
storageAsyncResult.CancelDelegate = tempExecutionState.Cancel;
if (storageAsyncResult.CancelRequested)
{
storageAsyncResult.Cancel();
}
};
Action oldActionToRun = actionToRun;
actionToRun = () => calculateMD5(oldActionToRun);
}
if (modifiedOptions.EncryptionPolicy != null)
{
Action<Action> encryptStream = continuation =>
{
SyncMemoryStream syncMemoryStream = new SyncMemoryStream();
options.AssertPolicyIfRequired();
sourceStream = syncMemoryStream;
if (modifiedOptions.EncryptionPolicy.EncryptionMode != BlobEncryptionMode.FullBlob)
{
throw new InvalidOperationException(SR.InvalidEncryptionMode, null);
}
ICryptoTransform transform = options.EncryptionPolicy.CreateAndSetEncryptionContext(this.Metadata, false /* noPadding */);
CryptoStream cryptoStream = new CryptoStream(syncMemoryStream, transform, CryptoStreamMode.Write);
StreamDescriptor streamCopyState = new StreamDescriptor();
source.WriteToAsync(cryptoStream, length, null, false, tempExecutionState, streamCopyState, completedState =>
{
ContinueAsyncOperation(storageAsyncResult, completedState, () =>
{
if (completedState.ExceptionRef != null)
{
storageAsyncResult.OnComplete(completedState.ExceptionRef);
}
else
{
// Flush the CryptoStream in order to make sure that the last block of data is flushed. This call is a sync call
// but it is ok to have it because we're just writing to a memory stream.
cryptoStream.FlushFinalBlock();
// After the tempStream has been written to, we need to seek back to the beginning, so that it can be read from.
sourceStream.Seek(0, SeekOrigin.Begin);
length = syncMemoryStream.Length;
continuation();
}
});
});
storageAsyncResult.CancelDelegate = tempExecutionState.Cancel;
if (storageAsyncResult.CancelRequested)
{
storageAsyncResult.Cancel();
}
};
Action oldActionToRun = actionToRun;
actionToRun = () => encryptStream(oldActionToRun);
}
actionToRun();
}
else
{
ICancellableAsyncResult result = this.BeginOpenWrite(
accessCondition,
modifiedOptions,
operationContext,
ar =>
{
ContinueAsyncOperation(storageAsyncResult, ar, () =>
{
CloudBlobStream blobStream = this.EndOpenWrite(ar);
storageAsyncResult.OperationState = blobStream;
source.WriteToAsync(
blobStream,
length,
null /* maxLength */,
false,
tempExecutionState,
null /* streamCopyState */,
completedState =>
{
ContinueAsyncOperation(storageAsyncResult, completedState, () =>
{
if (completedState.ExceptionRef != null)
{
storageAsyncResult.OnComplete(completedState.ExceptionRef);
}
else
{
ICancellableAsyncResult commitResult = blobStream.BeginCommit(
CloudBlob.BlobOutputStreamCommitCallback,
storageAsyncResult);
storageAsyncResult.CancelDelegate = commitResult.Cancel;
if (storageAsyncResult.CancelRequested)
{
storageAsyncResult.Cancel();
}
}
});
});
storageAsyncResult.CancelDelegate = tempExecutionState.Cancel;
if (storageAsyncResult.CancelRequested)
{
storageAsyncResult.Cancel();
}
});
},
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;
}
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;
}
