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;
}
public static void ParallelUpload(this CloudBlockBlob blobRef, string filename, BlobRequestOptions options)
{
if (null == options)
{
options = new BlobRequestOptions()
{
ServerTimeout = blobRef.ServiceClient.ServerTimeout,
//RetryPolicy = new ExponentialRetry(Microsoft.WindowsAzure.Storage.RetryPolicies..DefaultClientBackoff, RetryPolicies.DefaultClientRetryCount)
};
}
// get upload history if any
UploadInfo uploadInfo = UploadInfo.LoadByUploadFilename(filename);
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
{
blobRef.ParallelUpload(fs, uploadInfo, options);
}
// upload completed no history needed - delete it
if (File.Exists(uploadInfo.LogFilename))
File.Delete(uploadInfo.LogFilename);
Console.WriteLine("\nUpload completed.");
}
private Task<BlobResultSegment> ListBlobsSegmented(string prefix, bool useFlatBlobListing, BlobListingDetails blobListingDetails, int? maxResults, BlobContinuationToken continuationToken, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken = default(CancellationToken))
{
return AsyncTaskUtil.RunAsyncCancellable<BlobResultSegment>(
_inner.BeginListBlobsSegmented(prefix, useFlatBlobListing, blobListingDetails, maxResults, continuationToken, options, operationContext, null, null),
_inner.EndListBlobsSegmented,
cancellationToken);
}
private Task<ContainerResultSegment> ListContainersSegmented(string prefix, ContainerListingDetails detailsIncluded, int? maxResults, BlobContinuationToken continuationToken, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken = default(CancellationToken))
{
return AsyncTaskUtil.RunAsyncCancellable<ContainerResultSegment>(
_inner.BeginListContainersSegmented(prefix, detailsIncluded, maxResults, continuationToken, options, operationContext, null, null),
_inner.EndListContainersSegmented,
cancellationToken);
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializableBlobRequestOptions"/> class.
/// </summary>
/// <param name="info">Serialization information.</param>
/// <param name="context">Streaming context.</param>
private SerializableBlobRequestOptions(SerializationInfo info, StreamingContext context)
: base(info, context)
{
bool? disableContentMD5Validation = (bool?)info.GetValue(DisableContentMD5ValidationName, typeof(bool?));
TimeSpan? maximumExecutionTime = (TimeSpan?)info.GetValue(MaximumExecutionTimeName, typeof(TimeSpan?));
TimeSpan? serverTimeout = (TimeSpan?)info.GetValue(ServerTimeoutName, typeof(TimeSpan?));
bool? storeBlobContentMD5 = (bool?)info.GetValue(StoreBlobContentMD5Name, typeof(bool?));
bool? useTransactionalMD5 = (bool?)info.GetValue(UseTransactionalMD5Name, typeof(bool?));
if (null != disableContentMD5Validation
|| null != maximumExecutionTime
|| null != serverTimeout
|| null != storeBlobContentMD5
|| null != useTransactionalMD5)
{
this.blobRequestOptions = Transfer_RequestOptions.DefaultBlobRequestOptions;
this.blobRequestOptions.DisableContentMD5Validation = disableContentMD5Validation;
this.blobRequestOptions.MaximumExecutionTime = maximumExecutionTime;
this.blobRequestOptions.ServerTimeout = serverTimeout;
this.blobRequestOptions.StoreBlobContentMD5 = storeBlobContentMD5;
this.blobRequestOptions.UseTransactionalMD5 = useTransactionalMD5;
}
else
{
this.blobRequestOptions = null;
}
}
public Stream OpenWrite(long? size, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
this.attributes.AssertNoSnapshot();
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.PageBlob, this.ServiceClient);
bool createNew = size.HasValue;
if (createNew)
{
this.Create(size.Value, accessCondition, modifiedOptions, operationContext);
}
else
{
if (modifiedOptions.StoreBlobContentMD5.Value)
{
throw new ArgumentException(SR.MD5NotPossible);
}
this.FetchAttributes(accessCondition, modifiedOptions, operationContext);
size = this.Properties.Length;
}
if (accessCondition != null)
{
accessCondition = AccessCondition.GenerateLeaseCondition(accessCondition.LeaseId);
}
return new BlobWriteStream(this, size.Value, createNew, accessCondition, modifiedOptions, operationContext);
}
public Task<ServiceProperties> GetServiceProperties(BlobRequestOptions requestOptions = null, OperationContext operationContext = null, CancellationToken cancellationToken = default(CancellationToken))
{
return AsyncTaskUtil.RunAsyncCancellable<ServiceProperties>(
_inner.BeginGetServiceProperties(requestOptions, operationContext, null, null),
_inner.EndGetServiceProperties,
cancellationToken);
}
/// <summary>
/// UploadByteArray has been removed from Azure 2.0 SDK.
/// Adding a method here for backward compatibility
/// </summary>
/// <param name="blob"></param>
/// <param name="data"></param>
/// <param name="options"></param>
public static void UploadByteArray(this ICloudBlob blob, byte[] data, BlobRequestOptions options)
{
using (var ms = new MemoryStream(data))
{
blob.UploadFromStream(ms, null, options);
}
}
public Stream OpenRead(AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
this.FetchAttributes(accessCondition, options, operationContext);
AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, this.BlobType, this.ServiceClient, false);
return new BlobReadStream(this, streamAccessCondition, modifiedOptions, operationContext);
}
/// <summary>
/// Function to get Blob container
/// </summary>
/// <param name="containerName">container to look</param>
/// <returns>Blob container</returns>
public CloudBlobContainer GetBlobContainer()
{
// get the container reference
var blobContainer = blobClient.GetContainerReference(containerName);
try
{
// Create the container if it does not exist.
var options = new BlobRequestOptions
{
MaximumExecutionTime = TimeSpan.FromSeconds(2),
};
if (blobContainer.CreateIfNotExists())
{
// Set permissions on the container, if it was created.
var containerPermissions = new BlobContainerPermissions
{
PublicAccess = BlobContainerPublicAccessType.Off
};
blobContainer.SetPermissions(containerPermissions);
}
}
catch (Exception ex)
{
}
return blobContainer;
}
/// <summary>
/// On Task run successfully
/// </summary>
/// <param name="data">User data</param>
protected override void OnTaskSuccessful(DataMovementUserData data)
{
StorageBlob.CloudBlob blob = data.Data as StorageBlob.CloudBlob;
IStorageBlobManagement localChannel = data.Channel;
if (blob != null)
{
AccessCondition accessCondition = null;
StorageBlob.BlobRequestOptions requestOptions = RequestOptions;
if (BlobProperties != null || BlobMetadata != null)
{
Task[] tasks = new Task[2];
tasks[0] = SetBlobProperties(localChannel, blob, BlobProperties);
tasks[1] = SetBlobMeta(localChannel, blob, BlobMetadata);
Task.WaitAll(tasks);
}
try
{
localChannel.FetchBlobAttributesAsync(blob, accessCondition, requestOptions, OperationContext, CmdletCancellationToken).Wait();
}
catch (AggregateException e)
{
StorageException storageException = e.InnerException as StorageException;
//Handle the limited read permission.
if (storageException == null || !storageException.IsNotFoundException())
{
throw e.InnerException;
}
}
WriteCloudBlobObject(data.TaskId, localChannel, blob);
}
}
internal static BlobRequestOptions ApplyDefaults(BlobRequestOptions options, BlobType blobType, CloudBlobClient serviceClient, bool applyExpiry = true)
{
BlobRequestOptions modifiedOptions = new BlobRequestOptions(options);
modifiedOptions.RetryPolicy = modifiedOptions.RetryPolicy ?? serviceClient.RetryPolicy;
modifiedOptions.ServerTimeout = modifiedOptions.ServerTimeout ?? serviceClient.ServerTimeout;
modifiedOptions.MaximumExecutionTime = modifiedOptions.MaximumExecutionTime ?? serviceClient.MaximumExecutionTime;
if (applyExpiry && !modifiedOptions.OperationExpiryTime.HasValue && modifiedOptions.MaximumExecutionTime.HasValue)
{
modifiedOptions.OperationExpiryTime = DateTime.Now + modifiedOptions.MaximumExecutionTime.Value;
}
#if WINDOWS_PHONE
modifiedOptions.DisableContentMD5Validation = true;
modifiedOptions.StoreBlobContentMD5 = false;
modifiedOptions.UseTransactionalMD5 = false;
#else
modifiedOptions.DisableContentMD5Validation = modifiedOptions.DisableContentMD5Validation ?? false;
modifiedOptions.StoreBlobContentMD5 = modifiedOptions.StoreBlobContentMD5 ?? (blobType == BlobType.BlockBlob);
modifiedOptions.UseTransactionalMD5 = modifiedOptions.UseTransactionalMD5 ?? false;
#endif
return modifiedOptions;
}
public BlobResultSegment ListBlobsSegmented(string prefix, bool useFlatListing, BlobListingDetails blobListingDetails,
int? maxResults, BlobContinuationToken continuationToken, BlobRequestOptions blobRequestOptions,
OperationContext operationContext)
{
return _client.ListBlobsSegmented(prefix, useFlatListing, blobListingDetails, maxResults, continuationToken,
blobRequestOptions, operationContext);
}
public virtual Uri UploadFile(
string storageName,
Uri blobEndpointUri,
string storageKey,
string filePath,
BlobRequestOptions blobRequestOptions)
{
StorageCredentials credentials = new StorageCredentials(storageName, storageKey);
CloudBlobClient client = new CloudBlobClient(blobEndpointUri, credentials);
string blobName = string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}",
DateTime.UtcNow.ToString("yyyyMMdd_HHmmss", CultureInfo.InvariantCulture),
Path.GetFileName(filePath));
CloudBlobContainer container = client.GetContainerReference(ContainerName);
container.CreateIfNotExists();
CloudBlockBlob blob = container.GetBlockBlobReference(blobName);
BlobRequestOptions uploadRequestOption = blobRequestOptions ?? new BlobRequestOptions();
if (!uploadRequestOption.ServerTimeout.HasValue)
{
uploadRequestOption.ServerTimeout = TimeSpan.FromMinutes(300);
}
using (FileStream readStream = File.OpenRead(filePath))
{
blob.UploadFromStream(readStream, AccessCondition.GenerateEmptyCondition(), uploadRequestOption);
}
return new Uri(string.Format(CultureInfo.InvariantCulture, "{0}{1}{2}{3}", client.BaseUri, ContainerName, client.DefaultDelimiter, blobName));
}
private void DownloadFileFromBlobToDisk()
{
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(
ConfigurationManager.AppSettings["kcinfo344"]);
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference("lecture8");
BlobRequestOptions options = new BlobRequestOptions();
options.MaximumExecutionTime = new TimeSpan(0, 100, 0);
options.ServerTimeout = new TimeSpan(0, 100, 0);
if (container.Exists())
{
foreach (IListBlobItem item in container.ListBlobs(null, false))
{
if (item.GetType() == typeof(CloudBlockBlob))
{
CloudBlockBlob blob = (CloudBlockBlob)item;
LocalResource myStorage = RoleEnvironment.GetLocalResource("lessonStorage");
string filePath = Path.Combine(myStorage.RootPath, "wiki.txt");
using (FileStream fs = new FileStream(filePath, FileMode.Create))
{
blob.DownloadToStream(fs, null, options);
}
}
}
}
}
public async Task RetryDelayShouldBeCancellableAsync()
{
TaskCompletionSource<bool> responseTask = new TaskCompletionSource<bool>();
BlobRequestOptions options = new BlobRequestOptions();
options.RetryPolicy = new AlwaysRetry(TimeSpan.FromMinutes(1), 1);
OperationContext context = new OperationContext();
context.ResponseReceived += (sender, e) => responseTask.SetResult(true);
CloudBlobClient blobClient = GenerateCloudBlobClient();
CloudBlobContainer container = blobClient.GetContainerReference("test" + DateTime.UtcNow.Ticks.ToString());
CancellationTokenSource token = new CancellationTokenSource();
Task task = container.FetchAttributesAsync(null, options, context).AsTask(token.Token);
await responseTask.Task;
await Task.Delay(10 * 1000);
Stopwatch stopwatch = Stopwatch.StartNew();
try
{
token.Cancel();
await task;
}
catch (Exception)
{
// This is expected, because we went for an invalid domain name.
}
stopwatch.Stop();
Assert.IsTrue(stopwatch.Elapsed < TimeSpan.FromSeconds(10), stopwatch.Elapsed.ToString());
Assert.AreEqual(1, context.RequestResults.Count);
}
public static async Task<ReadOnlyCollection<IListBlobItem>> ListBlobsSegmentedAsync(
this CloudBlobDirectory container,
bool useFlatBlobListing,
int pageSize,
BlobListingDetails details,
BlobRequestOptions options,
OperationContext operationContext,
IProgress<IEnumerable<IListBlobItem>> progress = null,
CancellationToken cancellationToken = default(CancellationToken)) {
options = options ?? new BlobRequestOptions();
var results = new List<IListBlobItem>();
BlobContinuationToken continuation = null;
BlobResultSegment segment;
do {
segment = await Task.Factory.FromAsync(
(cb, state) => container.BeginListBlobsSegmented(useFlatBlobListing, details, pageSize, continuation, options, operationContext, cb, state).WithCancellation(cancellationToken),
ar => container.EndListBlobsSegmented(ar),
null);
if (progress != null) {
progress.Report(segment.Results);
}
results.AddRange(segment.Results);
continuation = segment.ContinuationToken;
} while (continuation != null);
return new ReadOnlyCollection<IListBlobItem>(results);
}
public async Task LocationModeWithMissingUriAsync()
{
AssertSecondaryEndpoint();
CloudBlobClient client = GenerateCloudBlobClient();
CloudBlobClient primaryOnlyClient = new CloudBlobClient(client.BaseUri, client.Credentials);
CloudBlobContainer container = primaryOnlyClient.GetContainerReference("nonexistingcontainer");
BlobRequestOptions options = new BlobRequestOptions()
{
LocationMode = LocationMode.SecondaryOnly,
RetryPolicy = new NoRetry(),
};
Exception e = await TestHelper.ExpectedExceptionAsync<Exception>(
async () => await container.FetchAttributesAsync(null, options, null),
"Request should fail when an URI is not provided for the target location");
Assert.IsInstanceOfType(e.InnerException, typeof(InvalidOperationException));
options.LocationMode = LocationMode.SecondaryThenPrimary;
e = await TestHelper.ExpectedExceptionAsync<Exception>(
async () => await container.FetchAttributesAsync(null, options, null),
"Request should fail when an URI is not provided for the target location");
Assert.IsInstanceOfType(e.InnerException, typeof(InvalidOperationException));
options.LocationMode = LocationMode.PrimaryThenSecondary;
e = await TestHelper.ExpectedExceptionAsync<Exception>(
async () => await container.FetchAttributesAsync(null, options, null),
"Request should fail when an URI is not provided for the target location");
Assert.IsInstanceOfType(e.InnerException, typeof(InvalidOperationException));
}
/// <summary>
/// Opens 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>
/// <returns>A stream to be used for writing to the blob.</returns>
public Stream OpenWrite(AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
this.attributes.AssertNoSnapshot();
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.BlockBlob, this.ServiceClient);
if ((accessCondition != null) && accessCondition.IsConditional)
{
try
{
this.FetchAttributes(accessCondition, modifiedOptions, operationContext);
}
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
{
throw;
}
}
}
return new BlobWriteStream(this, accessCondition, modifiedOptions, operationContext);
}
public virtual Task<CloudBlobStream> OpenWriteAsync(bool createNew, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
this.attributes.AssertNoSnapshot();
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.AppendBlob, this.ServiceClient, false);
if (!createNew && modifiedOptions.StoreBlobContentMD5.Value)
{
throw new ArgumentException(SR.MD5NotPossible);
}
return Task.Run(async () =>
{
if (createNew)
{
await this.CreateOrReplaceAsync(accessCondition, options, operationContext, cancellationToken);
}
else
{
// 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.
await this.FetchAttributesAsync(accessCondition, options, operationContext, cancellationToken);
}
if (accessCondition != null)
{
accessCondition = new AccessCondition() { LeaseId = accessCondition.LeaseId, IfAppendPositionEqual = accessCondition.IfAppendPositionEqual, IfMaxSizeLessThanOrEqual = accessCondition.IfMaxSizeLessThanOrEqual };
}
CloudBlobStream stream = new BlobWriteStream(this, accessCondition, modifiedOptions, operationContext);
return stream;
}, cancellationToken);
}
/// <summary>
/// Opens a stream for writing to the blob.
/// </summary>
/// <param name="size">The size of the write operation, in bytes. The size must be a multiple of 512.</param>
/// <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>
/// <returns>A stream to be used for writing to the blob.</returns>
public IAsyncOperation<IOutputStream> OpenWriteAsync(long? size, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
this.attributes.AssertNoSnapshot();
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.PageBlob, this.ServiceClient);
bool createNew = size.HasValue;
if (!createNew && modifiedOptions.StoreBlobContentMD5.Value)
{
throw new ArgumentException(SR.MD5NotPossible);
}
return AsyncInfo.Run(async (token) =>
{
if (createNew)
{
await this.CreateAsync(size.Value, accessCondition, modifiedOptions, operationContext);
}
else
{
await this.FetchAttributesAsync(accessCondition, modifiedOptions, operationContext);
size = this.Properties.Length;
}
if (accessCondition != null)
{
accessCondition = AccessCondition.GenerateLeaseCondition(accessCondition.LeaseId);
}
return new BlobWriteStream(this, size.Value, createNew, accessCondition, modifiedOptions, operationContext).AsOutputStream();
});
}
/// <summary>
/// set blob properties
/// </summary>
/// <param name="azureBlob">CloudBlob object</param>
/// <param name="meta">blob properties hashtable</param>
private async Task SetBlobProperties(IStorageBlobManagement localChannel, StorageBlob.CloudBlob blob, Hashtable properties)
{
if (properties == null)
{
return;
}
foreach (DictionaryEntry entry in properties)
{
string key = entry.Key.ToString();
string value = entry.Value.ToString();
Action <StorageBlob.BlobProperties, string> action = validCloudBlobProperties[key];
if (action != null)
{
action(blob.Properties, value);
}
}
AccessCondition accessCondition = null;
StorageBlob.BlobRequestOptions requestOptions = RequestOptions;
await Channel.SetBlobPropertiesAsync(blob, accessCondition, requestOptions, OperationContext, CmdletCancellationToken);
}
public Task SetServiceProperties(ServiceProperties properties, BlobRequestOptions requestOptions = null, OperationContext operationContext = null, CancellationToken cancellationToken = default(CancellationToken))
{
return AsyncTaskUtil.RunAsyncCancellable(
_inner.BeginSetServiceProperties(properties, requestOptions, operationContext, null, null),
_inner.EndSetServiceProperties,
cancellationToken);
}
/// <summary>
/// set blob meta
/// </summary>
/// <param name="azureBlob">CloudBlob object</param>
/// <param name="meta">meta data hashtable</param>
private async Task SetBlobMeta(IStorageBlobManagement localChannel, StorageBlob.CloudBlob blob, Hashtable meta)
{
if (meta == null)
{
return;
}
foreach (DictionaryEntry entry in meta)
{
string key = entry.Key.ToString();
string value = entry.Value.ToString();
if (blob.Metadata.ContainsKey(key))
{
blob.Metadata[key] = value;
}
else
{
blob.Metadata.Add(key, value);
}
}
AccessCondition accessCondition = null;
StorageBlob.BlobRequestOptions requestOptions = RequestOptions;
await Channel.SetBlobMetadataAsync(blob, accessCondition, requestOptions, OperationContext, CmdletCancellationToken);
}
/// <inheritdoc />
public Task<IStorageBlobResultSegment> ListBlobsSegmentedAsync(string prefix, bool useFlatBlobListing,
BlobListingDetails blobListingDetails, int? maxResults, BlobContinuationToken currentToken,
BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
Task<BlobResultSegment> sdkTask = _sdk.ListBlobsSegmentedAsync(prefix, useFlatBlobListing,
blobListingDetails, maxResults, currentToken, options, operationContext, cancellationToken);
return ListBlobsSegmentedAsyncCore(sdkTask);
}
/// <summary>
/// Initializes a new instance of the BlobWriteStreamBase class for a block blob.
/// </summary>
/// <param name="blockBlob">Blob reference to write to.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
protected BlobWriteStreamBase(CloudBlockBlob blockBlob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
: this(blockBlob.ServiceClient, accessCondition, options, operationContext)
{
this.blockBlob = blockBlob;
this.blockList = new List<string>();
this.blockIdPrefix = new Random().Next().ToString("X8") + "-";
this.buffer = new MemoryStream(this.Blob.StreamWriteSizeInBytes);
}
public AzureStorageProvider(AzureProviderOptions options)
{
_blobClient = CloudStorageAccount
.Parse(options.ConnectionString)
.CreateCloudBlobClient(); ;
_requestOptions = new BlobRequestOptions();
_context = new OperationContext();
}
public void Create(BlobContainerPublicAccessType accessType, BlobRequestOptions requestOptions = null, OperationContext operationContext = null)
{
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(requestOptions, BlobType.Unspecified, this.ServiceClient);
Executor.ExecuteSync(
this.CreateContainerImpl(modifiedOptions, accessType),
modifiedOptions.RetryPolicy,
operationContext);
}
public static string DownloadText(ICloudBlob blob, Encoding encoding, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
using (MemoryStream stream = new MemoryStream())
{
blob.DownloadToStream(stream, accessCondition, options, operationContext);
return encoding.GetString(stream.ToArray());
}
}
public async static Task DownloadToFileEncryptedAsync(this ICloudBlob blob, IBlobCryptoProvider provider, string path, FileMode mode,
AccessCondition accessCondition = null, BlobRequestOptions options = null,
OperationContext operationContext = null)
{
using (FileStream fileStream = new FileStream(path, mode))
{
await blob.DownloadToStreamEncryptedAsync(provider, fileStream, accessCondition, options, operationContext);
}
}
public static async Task<string> DownloadTextAsync(ICloudBlob blob, Encoding encoding, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
using (MemoryStream stream = new MemoryStream())
{
await blob.DownloadToStreamAsync(stream.AsOutputStream(), accessCondition, options, operationContext);
byte[] buffer = stream.ToArray();
return encoding.GetString(buffer, 0, buffer.Length);
}
}
public IAsyncAction CreateAsync(BlobContainerPublicAccessType accessType, BlobRequestOptions options, OperationContext operationContext)
{
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.Unspecified, this.ServiceClient);
return AsyncInfo.Run(async (token) => await Executor.ExecuteAsyncNullReturn(
this.CreateContainerImpl(modifiedOptions, accessType),
modifiedOptions.RetryPolicy,
operationContext,
token));
}
public async static Task UploadFromStreamEncryptedAsync(this ICloudBlob blob, IBlobCryptoProvider provider, Stream stream,
AccessCondition accessCondition = null, BlobRequestOptions options = null,
OperationContext operationContext = null)
{
using (Stream encryptedStream = provider.EncryptedStream(stream))
{
await blob.UploadFromStreamAsync(encryptedStream, accessCondition, options, operationContext);
}
}
/// <summary>
/// set blob AccessTier
/// </summary>
/// <param name="azureBlob">CloudBlob object</param>
/// <param name="blockBlobTier">Block Blob Tier</param>
/// <param name="pageBlobTier">Page Blob Tier</param>
private async Task SetBlobTier(IStorageBlobManagement localChannel, StorageBlob.CloudBlob blob, PremiumPageBlobTier?pageBlobTier)
{
if (pageBlobTier == null)
{
return;
}
StorageBlob.BlobRequestOptions requestOptions = RequestOptions;
// The Blob Type and Blob Tier must match, since already checked they are match at the begin of ExecuteCmdlet().
if (pageBlobTier != null)
{
await Channel.SetPageBlobTierAsync((CloudPageBlob)blob, pageBlobTier.Value, requestOptions, OperationContext, CmdletCancellationToken).ConfigureAwait(false);
}
}
/// <inheritdoc />
public override void Delete(IBlobContentLocation content)
{
CloudBlob blob = this.GetBlob(content);
try
{
var requestOptions = new Storage.Blob.BlobRequestOptions()
{
RetryPolicy = new Storage.RetryPolicies.NoRetry() // RetryPolicies.Retry(1, TimeSpan.FromSeconds(1))
};
blob.DeleteIfExists(DeleteSnapshotsOption.None, null, requestOptions, null);
}
catch (Exception e)
{
throw new BlobStorageException(string.Format("Cannot delete BLOB '{0}' from library storage '{1}'. {2}: {3}.", this.GetBlobName(content), this.Name, e.Source, e.Message), e);
}
}
// TODO: implement this
//public void DownloadRangeToStream(System.IO.Stream target, long? offset, long? length, Microsoft.WindowsAzure.Storage.AccessCondition accessCondition = null, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options = null, Microsoft.WindowsAzure.Storage.OperationContext operationContext = null)
//{
// ServerState ss = slaEngine.FindServerToRead(name);
// ICloudBlob blob = configuration.GetCloudBlobContainerDetail(ss.Name).GetCloudBlob(name);
// watch.Start();
// blob.DownloadRangeToStream(target, offset, length, accessCondition, options, operationContext);
// ss.AddRtt(watch.ElapsedMilliseconds);
// slaEngine.SessionState.RecordObjectRead(blob.Name, Timestamp(blob), ss);
//}
public bool Exists(Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options = null, Microsoft.WindowsAzure.Storage.OperationContext operationContext = null)
{
// Note sure that it's a good idea to ask a secondary site if a blob exists...
bool result = false;
protocol.Read(blob => result = blob.Exists(options, operationContext));
/*
* ServerState ss = slaEngine.FindServerToRead(Name);
* ICloudBlob blob = ClientRegistry.GetCloudBlob(ss.Name, configuration.Name, Name);
*
* watch.Start();
* bool result = blob.Exists(options, operationContext);
* ss.AddRtt(watch.ElapsedMilliseconds);
* // slaEngine.SessionState.RecordObjectRead(blob.Name, Timestamp(blob), ss);
* slaEngine.Session.RecordObjectRead(blob.Name, Timestamp(blob), ss, "");
*/
return(result);
}
public static void UploadFromFile(this StorageBlob.CloudBlob cloudBlob,
string path,
AccessCondition accessCondition = null,
StorageBlob.BlobRequestOptions options = null,
OperationContext operationContext = null)
{
if (StorageBlob.BlobType.BlockBlob == cloudBlob.BlobType)
{
(cloudBlob as StorageBlob.CloudBlockBlob).UploadFromFile(path, accessCondition, options, operationContext);
}
else if (StorageBlob.BlobType.PageBlob == cloudBlob.BlobType)
{
(cloudBlob as StorageBlob.CloudPageBlob).UploadFromFile(path, accessCondition, options, operationContext);
}
else if (StorageBlob.BlobType.AppendBlob == cloudBlob.BlobType)
{
(cloudBlob as StorageBlob.CloudAppendBlob).UploadFromFile(path, accessCondition, options, operationContext);
}
else
{
throw new InvalidOperationException(string.Format("Invalid blob type: {0}", cloudBlob.BlobType));
}
}
private void DoUploadFromStream(System.IO.Stream source, Microsoft.WindowsAzure.Storage.AccessCondition accessCondition = null, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options = null, Microsoft.WindowsAzure.Storage.OperationContext operationContext = null)
{
try
{
bool done = false;
while (!done)
{
using (PrimaryCloudBlobLease lease = new PrimaryCloudBlobLease(Name, configuration, true))
{
if (lease.HasLease)
{
foreach (string server in configuration.PrimaryServers)
{
watch.Start();
ICloudBlob blob = ClientRegistry.GetCloudBlob(server, configuration.Name, Name, false);
source.Position = 0;
blob.UploadFromStream(source, lease.getAccessConditionWithLeaseId(accessCondition), options, operationContext);
watch.Stop();
ServerState ss = slaEngine.Monitor.GetServerState(server);
ss.AddRtt(watch.ElapsedMilliseconds);
slaEngine.Session.RecordObjectWritten(Name, Timestamp(blob), ss);
}
done = true;
}
}
}
}
catch (StorageException se)
{
throw se;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Initializes a new instance of the BlobWriteStream class for a block blob.
/// </summary>
/// <param name="blockBlob">Blob reference to write to.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
internal BlobWriteStream(CloudBlockBlob blockBlob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
: base(blockBlob, accessCondition, options, operationContext)
{
}
/// <summary>
/// Initializes a new instance of the BlobWriteStream class for a page blob.
/// </summary>
/// <param name="pageBlob">Blob reference to write to.</param>
/// <param name="pageBlobSize">Size of the page blob.</param>
/// <param name="createNew">Use <c>true</c> if the page blob is newly created, <c>false</c> otherwise.</param>
/// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
/// <param name="options">An object that specifies any additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
internal BlobWriteStream(CloudPageBlob pageBlob, long pageBlobSize, bool createNew, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
: base(pageBlob, pageBlobSize, createNew, accessCondition, options, operationContext)
{
}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginUploadFromStream(System.IO.Stream source, AsyncCallback callback, object state)
//{
// return strongBlob.BeginUploadFromStream(source, callback, state);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginUploadFromStream(System.IO.Stream source, Microsoft.WindowsAzure.Storage.AccessCondition accessCondition, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options, Microsoft.WindowsAzure.Storage.OperationContext operationContext, AsyncCallback callback, object state)
//{
// return strongBlob.BeginUploadFromStream(source, accessCondition, options, operationContext, callback, state);
//}
//public void EndUploadFromStream(IAsyncResult asyncResult)
//{
// strongBlob.EndUploadFromStream(asyncResult);
// slaEngine.SessionState.RecordObjectWritten(strongBlob.Name, Timestamp(strongBlob), primaryServer);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginDownloadToStream(System.IO.Stream target, AsyncCallback callback, object state)
//{
// // TODO: Use SLA to decide from which server to download.
// return strongBlob.BeginDownloadToStream(target, callback, state);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginDownloadToStream(System.IO.Stream target, Microsoft.WindowsAzure.Storage.AccessCondition accessCondition, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options, Microsoft.WindowsAzure.Storage.OperationContext operationContext, AsyncCallback callback, object state)
//{
// return strongBlob.BeginDownloadToStream(target, accessCondition, options, operationContext, callback, state);
//}
//public void EndDownloadToStream(IAsyncResult asyncResult)
//{
// strongBlob.EndDownloadToStream(asyncResult);
// slaEngine.SessionState.RecordObjectRead(strongBlob.Name, Timestamp(strongBlob), primaryServer);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginDownloadRangeToStream(System.IO.Stream target, long? offset, long? length, AsyncCallback callback, object state)
//{
// return strongBlob.BeginDownloadRangeToStream(target, offset, length, callback, state);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginDownloadRangeToStream(System.IO.Stream target, long? offset, long? length, Microsoft.WindowsAzure.Storage.AccessCondition accessCondition, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options, Microsoft.WindowsAzure.Storage.OperationContext operationContext, AsyncCallback callback, object state)
//{
// return strongBlob.BeginDownloadRangeToStream(target, offset, length, accessCondition, options, operationContext, callback, state);
//}
//public void EndDownloadRangeToStream(IAsyncResult asyncResult)
//{
// strongBlob.EndDownloadRangeToStream(asyncResult);
// slaEngine.SessionState.RecordObjectRead(strongBlob.Name, Timestamp(strongBlob), primaryServer);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginExists(AsyncCallback callback, object state)
//{
// return strongBlob.BeginExists(callback, state);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginExists(Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options, Microsoft.WindowsAzure.Storage.OperationContext operationContext, AsyncCallback callback, object state)
//{
// return strongBlob.BeginExists(options, operationContext, callback, state);
//}
//public bool EndExists(IAsyncResult asyncResult)
//{
// bool result = strongBlob.EndExists(asyncResult);
// slaEngine.SessionState.RecordObjectRead(strongBlob.Name, Timestamp(strongBlob), primaryServer);
// return result;
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginFetchAttributes(AsyncCallback callback, object state)
//{
// return strongBlob.BeginFetchAttributes(callback, state);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginFetchAttributes(Microsoft.WindowsAzure.Storage.AccessCondition accessCondition, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options, Microsoft.WindowsAzure.Storage.OperationContext operationContext, AsyncCallback callback, object state)
//{
// return strongBlob.BeginFetchAttributes(accessCondition, options, operationContext, callback, state);
//}
//public void EndFetchAttributes(IAsyncResult asyncResult)
//{
// strongBlob.EndFetchAttributes(asyncResult);
// slaEngine.SessionState.RecordObjectRead(strongBlob.Name, Timestamp(strongBlob), primaryServer);
//}
//public void SetMetadata(Microsoft.WindowsAzure.Storage.AccessCondition accessCondition = null, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options = null, Microsoft.WindowsAzure.Storage.OperationContext operationContext = null)
//{
// watch.Start();
// strongBlob.SetMetadata(accessCondition, options, operationContext);
// primaryServer.AddRtt(watch.ElapsedMilliseconds);
// slaEngine.SessionState.RecordObjectWritten(strongBlob.Name, Timestamp(strongBlob), primaryServer);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginSetMetadata(AsyncCallback callback, object state)
//{
// return strongBlob.BeginSetMetadata(callback, state);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginSetMetadata(Microsoft.WindowsAzure.Storage.AccessCondition accessCondition, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options, Microsoft.WindowsAzure.Storage.OperationContext operationContext, AsyncCallback callback, object state)
//{
// return strongBlob.BeginSetMetadata(accessCondition, options, operationContext, callback, state);
//}
//public void EndSetMetadata(IAsyncResult asyncResult)
//{
// strongBlob.EndSetMetadata(asyncResult);
// slaEngine.SessionState.RecordObjectWritten(strongBlob.Name, Timestamp(strongBlob), primaryServer);
//}
//public void SetProperties(Microsoft.WindowsAzure.Storage.AccessCondition accessCondition = null, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options = null, Microsoft.WindowsAzure.Storage.OperationContext operationContext = null)
//{
// watch.Start();
// strongBlob.SetProperties(accessCondition, options, operationContext);
// primaryServer.AddRtt(watch.ElapsedMilliseconds);
// slaEngine.SessionState.RecordObjectWritten(strongBlob.Name, Timestamp(strongBlob), primaryServer);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginSetProperties(AsyncCallback callback, object state)
//{
// return strongBlob.BeginSetProperties(callback, state);
//}
//public Microsoft.WindowsAzure.Storage.ICancellableAsyncResult BeginSetProperties(Microsoft.WindowsAzure.Storage.AccessCondition accessCondition, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options, Microsoft.WindowsAzure.Storage.OperationContext operationContext, AsyncCallback callback, object state)
//{
// return strongBlob.BeginSetProperties(accessCondition, options, operationContext, callback, state);
//}
//public void EndSetProperties(IAsyncResult asyncResult)
//{
// strongBlob.EndSetProperties(asyncResult);
// slaEngine.SessionState.RecordObjectWritten(strongBlob.Name, Timestamp(strongBlob), primaryServer);
//}
public void Delete(Microsoft.WindowsAzure.Storage.Blob.DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None, Microsoft.WindowsAzure.Storage.AccessCondition accessCondition = null, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options = null, Microsoft.WindowsAzure.Storage.OperationContext operationContext = null)
{
bool isDone = false;
do
{
try
{
if (configuration.IsInFastMode())
{
DoDelete(deleteSnapshotsOption, accessCondition, options, operationContext);
isDone = true;
}
else
{
//We are not sure if reconfiguration is happening or not. We execute put in slow mode.
using (CloudBlobLease lease = new CloudBlobLease(configuration.Name, LeaseTakingPolicy.TryOnce))
{
if (lease.HasLease)
{
configuration.SyncWithCloud(ClientRegistry.GetConfigurationAccount());
DoDelete(deleteSnapshotsOption, accessCondition, options, operationContext);
isDone = true;
}
}
}
}
catch (StorageException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
} while (!isDone);
}
public virtual IEnumerable <IListBlobItem> ListBlobs(bool useFlatBlobListing = false, BlobListingDetails blobListingDetails = BlobListingDetails.None, BlobRequestOptions options = null, OperationContext operationContext = null)
{
return(this.Container.ListBlobs(this.Prefix, useFlatBlobListing, blobListingDetails, options, operationContext));
}
public virtual Task <BlobResultSegment> ListBlobsSegmentedAsync(bool useFlatBlobListing, BlobListingDetails blobListingDetails, int?maxResults, BlobContinuationToken currentToken, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return(AsyncExtensions.TaskFromApm(this.BeginListBlobsSegmented, this.EndListBlobsSegmented, useFlatBlobListing, blobListingDetails, maxResults, currentToken, options, operationContext, cancellationToken));
}
public virtual Task UploadFromStreamAsync(Stream source, long length, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual Task UploadFromStreamAsync(Stream source, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
throw new System.NotImplementedException();
}
public virtual Task UploadFromByteArrayAsync(byte[] buffer, int index, int count, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual Task PutBlockListAsync(IEnumerable <string> blockList, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public void FetchAttributes(Microsoft.WindowsAzure.Storage.AccessCondition accessCondition = null, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options = null, Microsoft.WindowsAzure.Storage.OperationContext operationContext = null)
{
// TODO: use protocol
ServerState ss = slaEngine.FindServerToRead(Name);
ICloudBlob blob = ClientRegistry.GetCloudBlob(ss.Name, configuration.Name, Name);
watch.Start();
blob.FetchAttributes(accessCondition, options, operationContext);
ss.AddRtt(watch.ElapsedMilliseconds);
// slaEngine.SessionState.RecordObjectRead(blob.Name, Timestamp(blob), ss);
slaEngine.Session.RecordObjectRead(blob.Name, Timestamp(blob), ss, "");
}
public virtual Task <string> DownloadTextAsync(Encoding encoding, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual Task <CloudBlockBlob> CreateSnapshotAsync(IDictionary <string, string> metadata, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual BlobResultSegment ListBlobsSegmented(bool useFlatBlobListing, BlobListingDetails blobListingDetails, int?maxResults, BlobContinuationToken currentToken, BlobRequestOptions options, OperationContext operationContext)
{
return(this.Container.ListBlobsSegmented(this.Prefix, useFlatBlobListing, blobListingDetails, maxResults, currentToken, options, operationContext));
}
public virtual Task <IEnumerable <ListBlockItem> > DownloadBlockListAsync(BlockListingFilter blockListingFilter, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
//public int StreamWriteSizeInBytes
//{
// get
// {
// return strongBlob.StreamWriteSizeInBytes;
// }
// set
// {
// strongBlob.StreamWriteSizeInBytes = value;
// eventualBlob.StreamWriteSizeInBytes = value;
// }
//}
//public int StreamMinimumReadSizeInBytes
//{
// get
// {
// return strongBlob.StreamMinimumReadSizeInBytes;
// }
// set
// {
// strongBlob.StreamMinimumReadSizeInBytes = value;
// eventualBlob.StreamMinimumReadSizeInBytes = value;
// }
//}
//public Microsoft.WindowsAzure.Storage.Blob.BlobProperties Properties
//{
// get { return strongBlob.Properties; }
//}
//public IDictionary<string, string> Metadata
//{
// get { return strongBlob.Metadata; }
//}
//public DateTimeOffset? SnapshotTime
//{
// get { return strongBlob.SnapshotTime; }
//}
//public Microsoft.WindowsAzure.Storage.Blob.CopyState CopyState
//{
// get { return strongBlob.CopyState; }
//}
//public Microsoft.WindowsAzure.Storage.Blob.BlobType BlobType
//{
// get { return strongBlob.BlobType; }
//}
/// <summary>
/// Upload to primary blobs from the provided stream.
///
/// Our put is using an optimization where it does not take lease on blobs if there is only one primary container.
/// </summary>
/// <param name="source"></param>
/// <param name="accessCondition"></param>
/// <param name="options"></param>
/// <param name="operationContext"></param>
public void UploadFromStream(System.IO.Stream source, Microsoft.WindowsAzure.Storage.AccessCondition accessCondition = null, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options = null, Microsoft.WindowsAzure.Storage.OperationContext operationContext = null)
{
source.Position = 0;
protocol.Write(blob => blob.UploadFromStream(source, /*lease.getAccessConditionWithLeaseId(accessCondition)*/ accessCondition, options, operationContext), accessCondition);
/*
* bool isDone = false;
*
* do
* {
* try
* {
*
* if (configuration.IsInFastMode())
* {
* DoUploadFromStream(source, accessCondition, options, operationContext);
* isDone = true;
* }
* else
* {
* //We are not sure if reconfiguration is happening or not. We execute put in slow mode.
* using (CloudBlobLease lease = new CloudBlobLease(configuration.Name, LeaseTakingPolicy.TryOnce))
* {
* if (lease.HasLease)
* {
* configuration.SyncWithCloud(ClientRegistry.GetConfigurationAccount());
* DoUploadFromStream(source, accessCondition, options, operationContext);
* isDone = true;
* }
* else
* {
* continue;
* }
* }
* }
* }
* catch (StorageException ex)
* {
* throw ex;
* }
* catch (Exception ex)
* {
* Console.WriteLine(ex.StackTrace.ToString());
* throw ex;
* }
* }
* while (!isDone);
*/
}
public async Task PageBlobWriteStreamBasicTestAsync()
{
byte[] buffer = GetRandomBuffer(6 * 512);
CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash();
CloudBlobContainer container = GetRandomContainerReference();
container.ServiceClient.ParallelOperationThreadCount = 2;
try
{
await container.CreateAsync();
CloudPageBlob blob = container.GetPageBlobReference("blob1");
blob.StreamWriteSizeInBytes = 8 * 512;
using (MemoryStream wholeBlob = new MemoryStream())
{
BlobRequestOptions options = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
using (IOutputStream writeStream = await blob.OpenWriteAsync(buffer.Length * 3, null, options, null))
{
Stream blobStream = writeStream.AsStreamForWrite();
for (int i = 0; i < 3; i++)
{
await blobStream.WriteAsync(buffer, 0, buffer.Length);
await wholeBlob.WriteAsync(buffer, 0, buffer.Length);
Assert.AreEqual(wholeBlob.Position, blobStream.Position);
hasher.Append(buffer.AsBuffer());
}
}
string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset());
await blob.FetchAttributesAsync();
Assert.AreEqual(md5, blob.Properties.ContentMD5);
using (MemoryOutputStream downloadedBlob = new MemoryOutputStream())
{
await blob.DownloadToStreamAsync(downloadedBlob);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream);
}
await TestHelper.ExpectedExceptionAsync <ArgumentException>(
async() => await blob.OpenWriteAsync(null, null, options, null),
"OpenWrite with StoreBlobContentMD5 on an existing page blob should fail");
using (IOutputStream writeStream = await blob.OpenWriteAsync(null))
{
Stream blobStream = writeStream.AsStreamForWrite();
blobStream.Seek(buffer.Length / 2, SeekOrigin.Begin);
wholeBlob.Seek(buffer.Length / 2, SeekOrigin.Begin);
for (int i = 0; i < 2; i++)
{
blobStream.Write(buffer, 0, buffer.Length);
wholeBlob.Write(buffer, 0, buffer.Length);
Assert.AreEqual(wholeBlob.Position, blobStream.Position);
}
wholeBlob.Seek(0, SeekOrigin.End);
}
await blob.FetchAttributesAsync();
Assert.AreEqual(md5, blob.Properties.ContentMD5);
using (MemoryOutputStream downloadedBlob = new MemoryOutputStream())
{
options.DisableContentMD5Validation = true;
await blob.DownloadToStreamAsync(downloadedBlob, null, options, null);
TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream);
}
}
}
finally
{
container.DeleteAsync().AsTask().Wait();
}
}
public virtual Task UploadTextAsync(string content, Encoding encoding, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
throw new System.NotImplementedException();
}
public virtual Task PutBlockAsync(string blockId, Stream blockData, string contentMD5, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual ICancellableAsyncResult BeginListBlobsSegmented(bool useFlatBlobListing, BlobListingDetails blobListingDetails, int?maxResults, BlobContinuationToken currentToken, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
{
return(this.Container.BeginListBlobsSegmented(this.Prefix, useFlatBlobListing, blobListingDetails, maxResults, currentToken, options, operationContext, callback, state));
}
public virtual Task <BlobResultSegment> ListBlobsSegmentedAsync(bool useFlatBlobListing, BlobListingDetails blobListingDetails, int?maxResults, BlobContinuationToken currentToken, BlobRequestOptions options, OperationContext operationContext)
{
return(this.ListBlobsSegmentedAsync(useFlatBlobListing, blobListingDetails, maxResults, currentToken, options, operationContext, CancellationToken.None));
}
private void DoDelete(Microsoft.WindowsAzure.Storage.Blob.DeleteSnapshotsOption deleteSnapshotsOption = DeleteSnapshotsOption.None, Microsoft.WindowsAzure.Storage.AccessCondition accessCondition = null, Microsoft.WindowsAzure.Storage.Blob.BlobRequestOptions options = null, Microsoft.WindowsAzure.Storage.OperationContext operationContext = null)
{
bool done = false;
while (!done)
{
using (PrimaryCloudBlobLease lease = new PrimaryCloudBlobLease(this.Name, configuration, true))
{
if (lease.HasLease)
{
Dictionary <ICloudBlob, IAsyncResult> results = new Dictionary <ICloudBlob, IAsyncResult>();
foreach (string serverName in configuration.PrimaryServers)
{
watch.Start();
ICloudBlob blob = ClientRegistry.GetCloudBlob(serverName, configuration.Name, Name);
results[blob] = blob.BeginDelete(deleteSnapshotsOption, lease.getAccessConditionWithLeaseId(accessCondition), options, operationContext, null, null);
ServerState ss = slaEngine.Monitor.GetServerState(serverName);
ss.AddRtt(watch.ElapsedMilliseconds);
slaEngine.Session.RecordObjectWritten(Name, Timestamp(blob), ss);
}
foreach (ICloudBlob blob in results.Keys)
{
blob.EndDelete(results[blob]);
}
done = true;
}
}
}
}
public async Task StoreBlobContentMD5TestAsync()
{
BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions()
{
StoreBlobContentMD5 = false,
};
BlobRequestOptions optionsWithMD5 = new BlobRequestOptions()
{
StoreBlobContentMD5 = true,
};
CloudBlobContainer container = GetRandomContainerReference();
try
{
await container.CreateAsync();
ICloudBlob blob = container.GetBlockBlobReference("blob1");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream(), null, optionsWithMD5, null);
}
await blob.FetchAttributesAsync();
Assert.IsNotNull(blob.Properties.ContentMD5);
blob = container.GetBlockBlobReference("blob2");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream(), null, optionsWithNoMD5, null);
}
await blob.FetchAttributesAsync();
Assert.IsNull(blob.Properties.ContentMD5);
blob = container.GetBlockBlobReference("blob3");
using (Stream stream = new NonSeekableMemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream());
}
await blob.FetchAttributesAsync();
Assert.IsNotNull(blob.Properties.ContentMD5);
blob = container.GetPageBlobReference("blob4");
using (Stream stream = new MemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream(), null, optionsWithMD5, null);
}
await blob.FetchAttributesAsync();
Assert.IsNotNull(blob.Properties.ContentMD5);
blob = container.GetPageBlobReference("blob5");
using (Stream stream = new MemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream(), null, optionsWithNoMD5, null);
}
await blob.FetchAttributesAsync();
Assert.IsNull(blob.Properties.ContentMD5);
blob = container.GetPageBlobReference("blob6");
using (Stream stream = new MemoryStream())
{
await blob.UploadFromStreamAsync(stream.AsInputStream());
}
await blob.FetchAttributesAsync();
Assert.IsNull(blob.Properties.ContentMD5);
}
finally
{
container.DeleteIfExistsAsync().AsTask().Wait();
}
}
