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 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>
/// 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 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 static HttpWebRequest GetFileRequest(FileContext context, string shareName, string fileName, AccessCondition accessCondition)
{
bool valid = FileTests.ShareNameValidator(shareName) &&
FileTests.FileNameValidator(fileName);
Uri uri = FileTests.ConstructGetUri(context.Address, shareName, fileName);
HttpWebRequest request = null;
OperationContext opContext = new OperationContext();
try
{
request = FileHttpWebRequestFactory.Get(uri, context.Timeout, accessCondition, true, opContext);
}
catch (InvalidOperationException)
{
if (valid)
{
Assert.Fail();
}
}
if (valid)
{
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual("GET", request.Method);
FileTestUtils.RangeHeader(request, null);
}
return request;
}
/// <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>
/// Constructs a web request to create a new block blob or page blob, or to update the content
/// of an existing block blob.
/// </summary>
/// <param name="uri">The absolute URI to the blob.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the blob.</param>
/// <param name="blobType">The type of the blob.</param>
/// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored
/// for block blobs.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Put(Uri uri, int? timeout, BlobProperties properties, BlobType blobType, long pageBlobSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
if (blobType == BlobType.Unspecified)
{
throw new InvalidOperationException(SR.UndefinedBlobType);
}
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext);
if (properties.CacheControl != null)
{
request.Headers.CacheControl = CacheControlHeaderValue.Parse(properties.CacheControl);
}
if (content != null)
{
if (properties.ContentType != null)
{
content.Headers.ContentType = MediaTypeHeaderValue.Parse(properties.ContentType);
}
if (properties.ContentMD5 != null)
{
content.Headers.ContentMD5 = Convert.FromBase64String(properties.ContentMD5);
}
if (properties.ContentLanguage != null)
{
content.Headers.ContentLanguage.Add(properties.ContentLanguage);
}
if (properties.ContentEncoding != null)
{
content.Headers.ContentEncoding.Add(properties.ContentEncoding);
}
if (properties.ContentDisposition != null)
{
content.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse(properties.ContentDisposition);
}
}
if (blobType == BlobType.PageBlob)
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.PageBlob);
request.Headers.Add(Constants.HeaderConstants.BlobContentLengthHeader, pageBlobSize.ToString(NumberFormatInfo.InvariantInfo));
properties.Length = pageBlobSize;
}
else if (blobType == BlobType.BlockBlob)
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.BlockBlob);
}
else
{
request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.AppendBlob);
}
request.ApplyAccessCondition(accessCondition);
return request;
}
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>
/// Applies the condition to the web request.
/// </summary>
/// <param name="request">The request to be modified.</param>
/// <param name="accessCondition">Access condition to be added to the request.</param>
internal static void ApplyAccessCondition(this HttpRequestMessage request, AccessCondition accessCondition)
{
if (accessCondition != null)
{
if (!string.IsNullOrEmpty(accessCondition.IfMatchETag))
{
request.Headers.IfMatch.Add(EntityTagHeaderValue.Parse(accessCondition.IfMatchETag));
}
if (!string.IsNullOrEmpty(accessCondition.IfNoneMatchETag))
{
if (accessCondition.IfNoneMatchETag.Equals(EntityTagHeaderValue.Any.ToString(), StringComparison.OrdinalIgnoreCase))
{
request.Headers.IfNoneMatch.Add(EntityTagHeaderValue.Any);
}
else
{
request.Headers.IfNoneMatch.Add(EntityTagHeaderValue.Parse(accessCondition.IfNoneMatchETag));
}
}
request.Headers.IfModifiedSince = accessCondition.IfModifiedSinceTime;
request.Headers.IfUnmodifiedSince = accessCondition.IfNotModifiedSinceTime;
if (!string.IsNullOrEmpty(accessCondition.LeaseId))
{
request.Headers.Add(Constants.HeaderConstants.LeaseIdHeader, accessCondition.LeaseId);
}
}
}
/// <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 virtual Stream OpenRead(AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
{
operationContext = operationContext ?? new OperationContext();
this.FetchAttributes(accessCondition, options, operationContext);
AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);
FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient, false);
return new FileReadStream(this, streamAccessCondition, modifiedOptions, operationContext);
}
public static async Task<string> DownloadTextAsync(CloudFile file, Encoding encoding, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
{
using (MemoryStream stream = new MemoryStream())
{
await file.DownloadToStreamAsync(stream, accessCondition, options, operationContext);
return encoding.GetString(stream.ToArray(), 0, (int)stream.Length);
}
}
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 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);
}
}
/// <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)
{
ChainedAsyncResult<Stream> chainedResult = new ChainedAsyncResult<Stream>(callback, state)
{
Result = this.OpenWrite(accessCondition, options, operationContext),
};
chainedResult.OnComplete();
return chainedResult;
}
public IAsyncOperation<IRandomAccessStreamWithContentType> OpenReadAsync(AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
return AsyncInfo.Run<IRandomAccessStreamWithContentType>(async (token) =>
{
await this.FetchAttributesAsync(accessCondition, options, operationContext).AsTask(token);
AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, this.BlobType, this.ServiceClient, false);
return new BlobReadStreamHelper(this, streamAccessCondition, modifiedOptions, operationContext);
});
}
/// <summary>
/// Constructs a web request to commit a block to an append blob.
/// </summary>
/// <param name="uri">A <see cref="System.Uri"/> specifying the absolute URI to the blob.</param>
/// <param name="timeout">An integer specifying the server timeout interval.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed.</param>
/// <param name="content"> The HTTP entity body and content headers.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
public static HttpRequestMessage AppendBlock(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = new UriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "appendblock");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
request.ApplyAccessCondition(accessCondition);
request.ApplyAppendCondition(accessCondition);
return request;
}
public virtual Task<Stream> OpenReadAsync(AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
return Task.Run<Stream>(async () =>
{
await this.FetchAttributesAsync(accessCondition, options, operationContext, cancellationToken);
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);
}, cancellationToken);
}
public static async Task UploadTextAsync(CloudFile file, string text, Encoding encoding, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
{
byte[] textAsBytes = encoding.GetBytes(text);
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
stream.Seek(0, SeekOrigin.Begin);
file.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
await file.UploadFromStreamAsync(stream, accessCondition, options, operationContext);
}
}
public CloudBlobStream OpenWrite(long? size, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
this.attributes.AssertNoSnapshot();
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, this.BlobType, this.ServiceClient, false);
bool createNew = size.HasValue;
#if !(WINDOWS_RT || ASPNET_K || PORTABLE)
ICryptoTransform transform = null;
modifiedOptions.AssertPolicyIfRequired();
if (modifiedOptions.EncryptionPolicy != null)
{
transform = modifiedOptions.EncryptionPolicy.CreateAndSetEncryptionContext(this.Metadata, true /* noPadding */);
}
#endif
if (createNew)
{
this.Create(size.Value, accessCondition, options, operationContext);
}
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
this.FetchAttributes(accessCondition, options, operationContext);
size = this.Properties.Length;
}
if (accessCondition != null)
{
accessCondition = AccessCondition.GenerateLeaseCondition(accessCondition.LeaseId);
}
#if !(WINDOWS_RT || ASPNET_K || PORTABLE)
if (modifiedOptions.EncryptionPolicy != null)
{
return new BlobEncryptedWriteStream(this, size.Value, createNew, accessCondition, modifiedOptions, operationContext, transform);
}
else
#endif
{
return new BlobWriteStream(this, size.Value, createNew, accessCondition, modifiedOptions, operationContext);
}
}
public virtual CloudBlobStream OpenWrite(bool createNew, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
this.attributes.AssertNoSnapshot();
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, this.BlobType, this.ServiceClient, false);
#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
this.CreateOrReplace(accessCondition, options, operationContext);
}
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.
this.FetchAttributes(accessCondition, options, operationContext);
}
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)
{
return new BlobEncryptedWriteStream(this, accessCondition, modifiedOptions, operationContext, transform);
}
else
#endif
{
return new BlobWriteStream(this, accessCondition, modifiedOptions, operationContext);
}
}
/// <summary>
/// Initializes a new instance of the BlobReadStreamBase class.
/// </summary>
/// <param name="blob">Blob reference to read from</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 BlobReadStreamBase(ICloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
this.blob = blob;
this.isLengthAvailable = false;
this.currentOffset = 0;
this.buffer = new MemoryStream();
this.accessCondition = accessCondition;
this.lockedToETag = false;
this.options = options;
this.operationContext = operationContext;
this.blobMD5 = options.DisableContentMD5Validation.Value ? null : new MD5Wrapper();
this.lastException = null;
}
/// <summary>
/// Initializes a new instance of the BlobWriteStreamBase class.
/// </summary>
/// <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>
private BlobWriteStreamBase(CloudBlobClient serviceClient, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
: base()
{
this.currentOffset = 0;
this.accessCondition = accessCondition;
this.options = options;
this.operationContext = operationContext;
this.pendingWrites = 0;
this.noPendingWritesEvent = new ManualResetEvent(true);
this.blobMD5 = options.StoreBlobContentMD5.Value ? new MD5Wrapper() : null;
this.blockMD5 = options.UseTransactionalMD5.Value ? new MD5Wrapper() : null;
this.parallelOperationSemaphore = new AsyncSemaphore(serviceClient.ParallelOperationThreadCount);
this.lastException = null;
}
/// <summary>
/// Initializes a new instance of the BlobWriteStreamBase class.
/// </summary>
/// <param name="serviceClient">The service client.</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed. If <c>null</c>, no condition is used.</param>
/// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
private BlobWriteStreamBase(CloudBlobClient serviceClient, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
: base()
{
this.internalBuffer = new MultiBufferMemoryStream(serviceClient.BufferManager);
this.accessCondition = accessCondition;
this.currentOffset = 0;
this.options = options;
this.operationContext = operationContext;
this.noPendingWritesEvent = new CounterEvent();
this.blobMD5 = this.options.StoreBlobContentMD5.Value ? new MD5Wrapper() : null;
this.blockMD5 = this.options.UseTransactionalMD5.Value ? new MD5Wrapper() : null;
this.parallelOperationSemaphore = new AsyncSemaphore(options.ParallelOperationThreadCount.Value);
this.lastException = null;
this.committed = false;
this.disposed = false;
}
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);
if (size.HasValue)
{
this.Create(size.Value, accessCondition, modifiedOptions, operationContext);
}
else
{
this.FetchAttributes(accessCondition, modifiedOptions, operationContext);
size = this.Properties.Length;
}
return new BlobWriteStream(this, size.Value, accessCondition, modifiedOptions, 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 <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed. If <c>null</c>, no condition is used.</param>
/// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
/// <param name="transform">The ICryptoTransform function for the request.</param>
internal BlobEncryptedWriteStream(CloudPageBlob pageBlob, long pageBlobSize, bool createNew, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, ICryptoTransform transform)
{
CommonUtility.AssertNotNull("transform", transform);
if (options.EncryptionPolicy.EncryptionMode != BlobEncryptionMode.FullBlob)
{
throw new InvalidOperationException(SR.InvalidEncryptionMode, null);
}
// Since this is done on the copy of the options object that the client lib maintains and not on the user's options object and is done after getting
// the transform function, it should be fine. Setting this ensures that an error is not thrown when PutPage is called internally from the write method on the stream.
options.SkipEncryptionPolicyValidation = true;
this.transform = transform;
this.writeStream = new BlobWriteStream(pageBlob, pageBlobSize, createNew, accessCondition, options, operationContext) { IgnoreFlush = true };
this.cryptoStream = new CryptoStream(this.writeStream, transform, CryptoStreamMode.Write);
}
public static HttpWebRequest PutBlobRequest(BlobContext context, string containerName, string blobName,
BlobProperties properties, BlobType blobType, byte[] content, long pageBlobSize, AccessCondition accessCondition)
{
bool valid = BlobTests.ContainerNameValidator(containerName) &&
BlobTests.BlobNameValidator(blobName) &&
BlobTests.PutPropertiesValidator(properties) &&
BlobTestUtils.ContentValidator(content);
bool fatal = !BlobTests.PutPropertiesValidator(properties);
Uri uri = BlobTests.ConstructPutUri(context.Address, containerName, blobName);
HttpWebRequest request = null;
OperationContext opContext = new OperationContext();
try
{
request = BlobHttpWebRequestFactory.Put(uri, context.Timeout, properties, blobType, pageBlobSize, accessCondition, opContext);
if (fatal)
{
Assert.Fail();
}
}
catch (InvalidOperationException)
{
if (valid)
{
Assert.Fail();
}
}
if (valid)
{
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual("PUT", request.Method);
BlobTestUtils.VersionHeader(request, false);
BlobTestUtils.ContentTypeHeader(request, null);
BlobTestUtils.ContentDispositionHeader(request, properties.ContentDisposition);
BlobTestUtils.ContentEncodingHeader(request, properties.ContentEncoding);
BlobTestUtils.ContentLanguageHeader(request, null);
BlobTestUtils.ContentMd5Header(request, null);
BlobTestUtils.CacheControlHeader(request, null);
BlobTestUtils.BlobTypeHeader(request, properties.BlobType);
BlobTestUtils.BlobSizeHeader(request, (properties.BlobType == BlobType.PageBlob) ? properties.Length : (long?)null);
}
return request;
}
/// <summary>
/// Constructs a web request to create a new file.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the file.</param>
/// <param name="fileSize">The size of the file.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</param>
/// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param>
/// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
public static HttpWebRequest Create(Uri uri, int? timeout, FileProperties properties, long fileSize, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
{
CommonUtility.AssertNotNull("properties", properties);
HttpWebRequest request = HttpWebRequestFactory.CreateWebRequest(WebRequestMethods.Http.Put, uri, timeout, null /* builder */, useVersionHeader, operationContext);
if (properties.CacheControl != null)
{
request.Headers[HttpRequestHeader.CacheControl] = properties.CacheControl;
}
if (properties.ContentType != null)
{
// Setting it using Headers is an exception
request.ContentType = properties.ContentType;
}
if (properties.ContentMD5 != null)
{
request.Headers[HttpRequestHeader.ContentMd5] = properties.ContentMD5;
}
if (properties.ContentLanguage != null)
{
request.Headers[HttpRequestHeader.ContentLanguage] = properties.ContentLanguage;
}
if (properties.ContentEncoding != null)
{
request.Headers[HttpRequestHeader.ContentEncoding] = properties.ContentEncoding;
}
if (properties.ContentDisposition != null)
{
request.Headers[Constants.HeaderConstants.FileContentDispositionRequestHeader] = properties.ContentDisposition;
}
request.Headers[Constants.HeaderConstants.FileType] = Constants.HeaderConstants.File;
request.Headers[Constants.HeaderConstants.FileContentLengthHeader] = fileSize.ToString(NumberFormatInfo.InvariantInfo);
properties.Length = fileSize;
request.ApplyAccessCondition(accessCondition);
return request;
}
/// <summary>
/// Initializes a new instance of the BlobReadStreamBase class.
/// </summary>
/// <param name="blob">Blob reference to read from</param>
/// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the condition that must be met in order for the request to proceed. If <c>null</c>, no condition is used.</param>
/// <param name="options">A <see cref="BlobRequestOptions"/> object that specifies additional options for the request.</param>
/// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param>
protected BlobReadStreamBase(CloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
if (options.UseTransactionalMD5.Value)
{
CommonUtility.AssertInBounds("StreamMinimumReadSizeInBytes", blob.StreamMinimumReadSizeInBytes, 1, Constants.MaxRangeGetContentMD5Size);
}
this.blob = blob;
this.blobProperties = new BlobProperties(blob.Properties);
this.currentOffset = 0;
this.streamMinimumReadSizeInBytes = this.blob.StreamMinimumReadSizeInBytes;
this.internalBuffer = new MultiBufferMemoryStream(blob.ServiceClient.BufferManager);
this.accessCondition = accessCondition;
this.options = options;
this.operationContext = operationContext;
this.blobMD5 = (this.options.DisableContentMD5Validation.Value || string.IsNullOrEmpty(this.blobProperties.ContentMD5)) ? null : new MD5Wrapper();
this.lastException = null;
}
/// <summary>
/// Constructs a web request to create a new file.
/// </summary>
/// <param name="uri">The absolute URI to the file.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="properties">The properties to set for the file.</param>
/// <param name="fileSize">For a file, the size of the file. This parameter is ignored
/// for block files.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static StorageRequestMessage Create(Uri uri, int? timeout, FileProperties properties, long fileSize, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
{
StorageRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, null /* builder */, content, operationContext, canonicalizer, credentials);
if (properties.CacheControl != null)
{
request.Headers.CacheControl = CacheControlHeaderValue.Parse(properties.CacheControl);
}
if (content != null)
{
if (properties.ContentType != null)
{
content.Headers.ContentType = MediaTypeHeaderValue.Parse(properties.ContentType);
}
if (properties.ContentMD5 != null)
{
content.Headers.ContentMD5 = Convert.FromBase64String(properties.ContentMD5);
}
if (properties.ContentLanguage != null)
{
content.Headers.ContentLanguage.Add(properties.ContentLanguage);
}
if (properties.ContentEncoding != null)
{
content.Headers.ContentEncoding.Add(properties.ContentEncoding);
}
if (properties.ContentDisposition != null)
{
content.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse(properties.ContentDisposition);
}
}
request.Headers.Add(Constants.HeaderConstants.FileType, Constants.HeaderConstants.File);
request.Headers.Add(Constants.HeaderConstants.FileContentLengthHeader, fileSize.ToString(NumberFormatInfo.InvariantInfo));
properties.Length = fileSize;
request.ApplyAccessCondition(accessCondition);
return request;
}
public virtual Task <int> DownloadRangeToByteArrayAsync(byte[] target, int index, long?fileOffset, long?length, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual Task <bool> DeleteIfExistsAsync(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual Task SetPropertiesAsync(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
throw new System.NotImplementedException();
}
public virtual Task SetMetadataAsync(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual Task ClearRangeAsync(long startOffset, long length, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public virtual Task <string> StartCopyAsync(CloudBlob source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, FileRequestOptions options, OperationContext operationContext)
{
throw new System.NotImplementedException();
}
private RESTCommand <NullType> GetFileImpl(Stream destStream, long?offset, long?length, AccessCondition accessCondition, FileRequestOptions options)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Initializes a new instance of the BlobReadStrea class.
/// </summary>
/// <param name="blob">Blob reference to read from</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 BlobReadStream(ICloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
: base(blob, accessCondition, options, operationContext)
{
this.parallelOperationSemaphore = new AsyncSemaphore(1);
}
public static void UploadTextAPM(ICloudBlob blob, string text, Encoding encoding, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
byte[] textAsBytes = encoding.GetBytes(text);
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
if (blob.BlobType == BlobType.PageBlob)
{
int lastPageSize = (int)(stream.Length % 512);
if (lastPageSize != 0)
{
byte[] padding = new byte[512 - lastPageSize];
stream.Write(padding, 0, padding.Length);
}
}
stream.Seek(0, SeekOrigin.Begin);
blob.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
using (AutoResetEvent waitHandle = new AutoResetEvent(false))
{
IAsyncResult result = blob.BeginUploadFromStream(stream, accessCondition, options, operationContext,
ar => waitHandle.Set(),
null);
waitHandle.WaitOne();
blob.EndUploadFromStream(result);
}
}
}
public static void UploadTextTask(ICloudBlob blob, string text, Encoding encoding, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
{
byte[] textAsBytes = encoding.GetBytes(text);
using (MemoryStream stream = new MemoryStream())
{
stream.Write(textAsBytes, 0, textAsBytes.Length);
if (blob.BlobType == BlobType.PageBlob)
{
int lastPageSize = (int)(stream.Length % 512);
if (lastPageSize != 0)
{
byte[] padding = new byte[512 - lastPageSize];
stream.Write(padding, 0, padding.Length);
}
}
stream.Seek(0, SeekOrigin.Begin);
blob.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
try
{
blob.UploadFromStreamAsync(stream, accessCondition, options, operationContext).Wait();
}
catch (AggregateException ex)
{
if (ex.InnerException != null)
{
throw ex.InnerException;
}
throw;
}
}
}
public Task <ICloudBlob> GetBlobReferenceFromServerAsync(Uri blobUri, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
public IAsyncOperation <ICloudBlob> GetBlobReferenceFromServerAsync(Uri blobUri, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
#endif
{
CommonUtility.AssertNotNull("blobUri", blobUri);
return(this.GetBlobReferenceFromServerAsync(new StorageUri(blobUri), accessCondition, options, operationContext));
}
public Task <ICloudBlob> GetBlobReferenceFromServerAsync(StorageUri blobUri, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
return(this.GetBlobReferenceFromServerAsync(blobUri, accessCondition, options, operationContext, CancellationToken.None));
}
public virtual Task DownloadRangeToStreamAsync(Stream target, long?offset, long?length, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
private RESTCommand <NullType> FetchAttributesImpl(AccessCondition accessCondition, FileRequestOptions options)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Constructs a web request to set the ACL for a container.
/// </summary>
/// <param name="uri">The absolute URI to the container.</param>
/// <param name="timeout">The server timeout interval.</param>
/// <param name="publicAccess">The type of public access to allow for the container.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns><returns>A web request to use to perform the operation.</returns></returns>
public static HttpRequestMessage SetAcl(Uri uri, int?timeout, BlobContainerPublicAccessType publicAccess, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
HttpRequestMessage request = HttpRequestMessageFactory.SetAcl(uri, timeout, GetContainerUriQueryBuilder(), content, operationContext);
if (publicAccess != BlobContainerPublicAccessType.Off)
{
request.Headers.Add(Constants.HeaderConstants.ContainerPublicAccessType, publicAccess.ToString().ToLower());
}
request.ApplyAccessCondition(accessCondition);
return(request);
}
public virtual Task AbortCopyAsync(string copyId, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Generates a web request to use to acquire, renew, change, release or break the lease for the container.
/// </summary>
/// <param name="uri">The absolute URI to the container.</param>
/// <param name="timeout">The server timeout interval, in seconds.</param>
/// <param name="action">The lease action to perform.</param>
/// <param name="proposedLeaseId">A lease ID to propose for the result of an acquire or change operation,
/// or null if no ID is proposed for an acquire operation. This should be null for renew, release, and break operations.</param>
/// <param name="leaseDuration">The lease duration, in seconds, for acquire operations.
/// If this is -1 then an infinite duration is specified. This should be null for renew, change, release, and break operations.</param>
/// <param name="leaseBreakPeriod">The amount of time to wait, in seconds, after a break operation before the lease is broken.
/// If this is null then the default time is used. This should be null for acquire, renew, change, and release operations.</param>
/// <param name="accessCondition">The access condition to apply to the request.</param>
/// <returns>A web request to use to perform the operation.</returns>
public static HttpRequestMessage Lease(Uri uri, int?timeout, LeaseAction action, string proposedLeaseId, int?leaseDuration, int?leaseBreakPeriod, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
{
UriQueryBuilder builder = GetContainerUriQueryBuilder();
builder.Add(Constants.QueryConstants.Component, "lease");
HttpRequestMessage request = HttpRequestMessageFactory.CreateRequestMessage(HttpMethod.Put, uri, timeout, builder, content, operationContext);
// Add Headers
BlobHttpRequestMessageFactory.AddLeaseAction(request, action);
BlobHttpRequestMessageFactory.AddLeaseDuration(request, leaseDuration);
BlobHttpRequestMessageFactory.AddProposedLeaseId(request, proposedLeaseId);
BlobHttpRequestMessageFactory.AddLeaseBreakPeriod(request, leaseBreakPeriod);
request.ApplyAccessCondition(accessCondition);
return(request);
}
public virtual Task <string> StartCopyAsync(Uri source, AccessCondition sourceAccessCondition, AccessCondition destAccessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
private RESTCommand <NullType> ClearRangeImpl(long startOffset, long length, AccessCondition accessCondition, FileRequestOptions options)
{
throw new System.NotImplementedException();
}
public virtual Task WriteRangeAsync(Stream rangeData, long startOffset, string contentMD5, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
private RESTCommand <NullType> PutRangeImpl(Stream rangeData, long startOffset, string contentMD5, AccessCondition accessCondition, FileRequestOptions options)
{
throw new System.NotImplementedException();
}
public virtual Task ResizeAsync(long size, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
throw new System.NotImplementedException();
}
private RESTCommand <NullType> SetMetadataImpl(AccessCondition accessCondition, FileRequestOptions options)
{
throw new System.NotImplementedException();
}
public virtual Task <IEnumerable <FileRange> > ListRangesAsync(long?offset, long?length, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
private RESTCommand <NullType> ResizeImpl(long sizeInBytes, AccessCondition accessCondition, FileRequestOptions options)
{
throw new System.NotImplementedException();
}
public virtual Task CreateAsync(long size, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
private RESTCommand <IEnumerable <FileRange> > ListRangesImpl(long?offset, long?length, AccessCondition accessCondition, FileRequestOptions options)
{
throw new System.NotImplementedException();
}
public virtual Task <int> DownloadToByteArrayAsync(byte[] target, int index, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
{
throw new System.NotImplementedException();
}
public IAsyncOperation <ICloudBlob> GetBlobReferenceFromServerAsync(StorageUri blobUri, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
{
CommonUtility.AssertNotNull("blobUri", blobUri);
BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.Unspecified, this);
return(AsyncInfo.Run(async(token) => await Executor.ExecuteAsync(
this.GetBlobReferenceImpl(blobUri, accessCondition, modifiedOptions),
modifiedOptions.RetryPolicy,
operationContext,
token)));
}
