/// <summary> /// Constructs a web request to delete the container and all of the blobs within it. /// </summary> /// <param name="uri">The absolute URI to the container.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static HttpWebRequest Delete(Uri uri, int? timeout, AccessCondition accessCondition, OperationContext operationContext) { UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder(); HttpWebRequest request = HttpWebRequestFactory.Delete(uri, containerBuilder, timeout, operationContext); request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Constructs a web request to delete the directory and all of the files within it. /// </summary> /// <param name="uri">The absolute URI to the directory.</param> /// <param name="timeout">The server timeout interval.</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 Delete(Uri uri, int? timeout, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext) { UriQueryBuilder directoryBuilder = GetDirectoryUriQueryBuilder(); HttpWebRequest request = HttpWebRequestFactory.Delete(uri, directoryBuilder, timeout, useVersionHeader, operationContext); request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Generates a web request to return the properties and user-defined metadata for this directory. /// </summary> /// <param name="uri">The absolute URI to the directory.</param> /// <param name="timeout">The server timeout interval.</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 GetProperties(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext) { UriQueryBuilder directoryBuilder = GetDirectoryUriQueryBuilder(); HttpRequestMessage request = HttpRequestMessageFactory.GetProperties(uri, timeout, directoryBuilder, content, operationContext); request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Generates a web request to return the user-defined metadata for this container. /// </summary> /// <param name="uri">The absolute URI to the container.</param> /// <param name="timeout">The server timeout interval.</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 GetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder(); StorageRequestMessage request = HttpRequestMessageFactory.GetMetadata(uri, timeout, containerBuilder, content, operationContext, canonicalizer, credentials); request.ApplyAccessCondition(accessCondition); return request; }
/// <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 HttpWebRequest request, AccessCondition accessCondition) { if (accessCondition != null) { if (!string.IsNullOrEmpty(accessCondition.IfMatchETag)) { request.Headers[HttpRequestHeader.IfMatch] = accessCondition.IfMatchETag; } if (!string.IsNullOrEmpty(accessCondition.IfNoneMatchETag)) { request.Headers[HttpRequestHeader.IfNoneMatch] = accessCondition.IfNoneMatchETag; } if (accessCondition.IfModifiedSinceTime.HasValue) { // Not using this property will cause Restricted property exception to be thrown request.IfModifiedSince = accessCondition.IfModifiedSinceTime.Value.UtcDateTime; } if (accessCondition.IfNotModifiedSinceTime.HasValue) { request.Headers[HttpRequestHeader.IfUnmodifiedSince] = HttpUtility.ConvertDateTimeToHttpString(accessCondition.IfNotModifiedSinceTime.Value); } if (!string.IsNullOrEmpty(accessCondition.LeaseId)) { request.Headers[Constants.HeaderConstants.LeaseIdHeader] = accessCondition.LeaseId; } } }
/// <summary> /// Generates a web request to return the user-defined metadata for this container. /// </summary> /// <param name="uri">The absolute URI to the container.</param> /// <param name="timeout">The server timeout interval.</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 GetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext) { UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder(); HttpRequestMessage request = HttpRequestMessageFactory.GetMetadata(uri, timeout, containerBuilder, content, operationContext); request.ApplyAccessCondition(accessCondition); return request; }
public async virtual void UploadBlockBlobAsync(string blobName, Stream streamToUpload, string contentType, AccessCondition accessCondition = null) { var blockBlob = GetBlockBlobReference(blobName); blockBlob.Properties.ContentType = contentType; await blockBlob.UploadFromStreamAsync(streamToUpload, accessCondition, null, null); }
/// <summary> /// Constructs a web request to delete the share and all of the files within it. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="timeout">The server timeout interval.</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 Delete(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext) { UriQueryBuilder shareBuilder = GetShareUriQueryBuilder(); HttpRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, shareBuilder, content, operationContext); request.ApplyAccessCondition(accessCondition); return request; }
/// <summary> /// Generates a web request to return the user-defined metadata for this share. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="timeout">The server timeout interval.</param> /// <param name="accessCondition">The access condition to apply to the request.</param> /// <param name="useVersionHeader">A flag indicating whether to set the x-ms-version HTTP header.</param> /// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param> /// <returns>A web request to use to perform the operation.</returns> public static HttpWebRequest GetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext) { UriQueryBuilder shareBuilder = GetShareUriQueryBuilder(); HttpWebRequest request = HttpWebRequestFactory.GetMetadata(uri, timeout, shareBuilder, useVersionHeader, operationContext); request.ApplyAccessCondition(accessCondition); return request; }
static async Task UploadTextAsync(ICloudBlob blob, string text, AccessCondition accessCondition) { blob.Properties.ContentEncoding = "UTF-8"; blob.Properties.ContentType = "text/plain"; using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(text))) { await blob.UploadFromStreamAsync(stream, accessCondition, null, null); } }
/// <summary> /// Constructs a web request to delete the share and all of the files within it. /// </summary> /// <param name="uri">The absolute URI to the share.</param> /// <param name="timeout">The server timeout interval.</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 Delete(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials) { UriQueryBuilder shareBuilder = GetShareUriQueryBuilder(); StorageRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, shareBuilder, content, operationContext, canonicalizer, credentials); request.ApplyAccessCondition(accessCondition); return request; }
public static void Run() { #region Obtain a client from the connection string CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString")); CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient(); Console.WriteLine("Parsed connection string and created blob client."); #endregion #region Obtain reference to images container CloudBlobContainer imageContainer = blobClient.GetContainerReference("images"); Console.WriteLine("Obtained reference to images container."); #endregion #region Show concurrency management using ETag property Console.WriteLine(); CloudBlockBlob blockBlob1 = imageContainer.GetBlockBlobReference(@"rocks/WhitePocketFocus.jpg"); CloudBlockBlob blockBlob2 = imageContainer.GetBlockBlobReference(@"rocks/WhitePocketFocus.jpg"); blockBlob1.FetchAttributes(); blockBlob2.FetchAttributes(); Console.WriteLine("[1] Obtained ETag {0} for rocks/WhitePocketFocus.jpg in images container.", blockBlob1.Properties.ETag); Console.WriteLine("[2] Obtained ETag {0} for rocks/WhitePocketFocus.jpg in images container.", blockBlob2.Properties.ETag); var etag = blockBlob1.Properties.ETag; var accessCondition = new AccessCondition {IfMatchETag = etag}; var metadata = new Dictionary<string, string>() { { "License", "snowpeak" }, { "URL", "http://www.flickr.com/photos/snowpeak/7394540572/sizes/l/in/pool-809956@N25/"} }; Console.WriteLine("[1] Setting metadata on rocks/WhitePocketFocus.jpg in images container."); foreach (KeyValuePair<string, string> pair in metadata) { blockBlob1.Metadata.Add(pair); } blockBlob1.SetMetadata(accessCondition); blockBlob1.FetchAttributes(); Console.WriteLine("[1] New ETag {0} for rocks/WhitePocketFocus.jpg in images container.", blockBlob1.Properties.ETag); try { Console.WriteLine("[2] Setting metadata on rocks/WhitePocketFocus.jpg in images container."); foreach (KeyValuePair<string, string> pair in metadata) { blockBlob2.Metadata.Add(pair); } blockBlob2.SetMetadata(accessCondition); } catch (Exception exception) { Console.WriteLine("[2] Caught exception '" + exception.GetType() + "' while trying to set metadata on rocks/WhitePocketFocus.jpg in images container."); Console.WriteLine(exception.StackTrace); } #endregion }
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); } }
static void UploadText(ICloudBlob blob, string text, AccessCondition accessCondition) { blob.Properties.ContentEncoding = "UTF-8"; blob.Properties.ContentType = "text/plain"; using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(text))) { blob.UploadFromStream(stream, accessCondition); } }
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 AzureWriteBlockBlobStream(CloudBlockBlob blob, AccessCondition condition) { _blob = blob; _condition = condition; long min = Math.Min(blob.Properties.Length, AzureBlockSize); if (min < 0) { min = 0; } _buff = new MemoryStream((int)min); _partNumber = 1; }
public static void DownloadToStreamEncrypted(this ICloudBlob blob, IBlobCryptoProvider provider, Stream stream, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null) { using (Stream blobStream = blob.OpenRead(accessCondition, options, operationContext)) using (Stream decryptedStream = provider.DecryptedStream(blobStream)) { decryptedStream.CopyTo(stream); } }
public async static Task UploadFromFileEncryptedAsync(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)) using (Stream encryptedStream = provider.EncryptedStream(fileStream)) { await blob.UploadFromStreamAsync(encryptedStream, accessCondition, options, operationContext); } }
public static CloudBlockBlob Upload(this CloudBlockBlob blob, string text , AccessCondition accessCondition = null, BlobRequestOptions blobRequestOptions = null, OperationContext operationContext = null) { var bytes = Encoding.UTF8.GetBytes(text); using (var ms = new MemoryStream(bytes)) { blob.UploadFromStream(ms, accessCondition, blobRequestOptions, operationContext); } return blob; }
public static CloudBlob GetBlobReferenceFromServer( CloudBlobContainer container, string blobName, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null) { CloudBlob blob = container.GetBlobReference(blobName); return GetBlobReferenceFromServer(blob, accessCondition, options, operationContext); }
public Task FetchShareAttributesAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken token) { if (this.availableShareNames.Contains(share.Name)) { return TaskEx.FromResult(true); } else { throw new MockupException("ShareNotExist"); } }
public async Task UploadFromByteArrayAsync(string blobName, byte[] buffer, int index, int count, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext) { var blob = await CreateCloudBlockBlobAsync(blobName); await blob.UploadFromByteArrayAsync( buffer, index, count, accessCondition, options, operationContext); }
public static void UploadText(this CloudBlockBlob blockBlob, string content, AccessCondition accessCondition = null) { using (var stream = blockBlob.OpenWrite(accessCondition)) { var encoding = new UTF8Encoding(); var buffer = encoding.GetBytes(content); stream.Write(buffer, 0, buffer.Length); stream.Flush(); stream.Close(); } }
/// <summary> /// UploadFromStreamAsync /// </summary> /// <param name="blob"></param> /// <param name="sourceStream"></param> /// <param name="accessCondition"></param> /// <param name="options"></param> /// <param name="operationContext"></param> /// <returns></returns> public static async Task UploadFromStreamAsync(this ICloudBlob blob, Stream sourceStream, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext) { Func<AsyncCallback, Object, IAsyncResult> beginMethod = (cb, state) => { return blob.BeginUploadFromStream(sourceStream, accessCondition, options, operationContext, cb, state); }; Action<IAsyncResult> endMethod = (r) => { blob.EndUploadFromStream(r); }; await Task.Factory.FromAsync(beginMethod, endMethod, null); }
public static byte[] GetBlobBinary(this CloudBlockBlob blob, AccessCondition accessCondition = null, BlobRequestOptions blobRequestOptions = null, OperationContext operationContext = null) { byte[] bytes; blob.FetchAttributes(); var blobSize = blob.Properties.Length; using (var memoryStream = new MemoryStream((int)blobSize)) { blob.DownloadToStream(memoryStream, accessCondition, blobRequestOptions, operationContext); bytes = memoryStream.ToArray(); } return bytes; }
/// <summary> /// Returns an enumerable collection of the blob's blocks, using the specified block list filter asynchronously. /// </summary> /// <param name="blockBlob">Cloud block blob.</param> /// <param name="blockListingFilter"> /// One of the enumeration values that indicates whether to return /// committed blocks, uncommitted blocks, or both. /// </param> /// <param name="accessCondition"> /// An <see cref="T:Microsoft.WindowsAzure.Storage.AccessCondition" /> object that represents the access conditions for the blob. If <c>null</c>, no condition is used. /// </param> /// <param name="cancellationToken">Cancellation token.</param> /// <returns> /// An enumerable collection of objects implementing <see cref="T:Microsoft.WindowsAzure.Storage.Blob.ListBlockItem" />. /// </returns> public static Task<IEnumerable<ListBlockItem>> DownloadBlockListAsync( this CloudBlockBlob blockBlob, BlockListingFilter blockListingFilter = BlockListingFilter.Committed, AccessCondition accessCondition = null, CancellationToken cancellationToken = default (CancellationToken)) { ICancellableAsyncResult asyncResult = blockBlob.BeginDownloadBlockList(blockListingFilter, accessCondition, null, null, null, null); CancellationTokenRegistration registration = cancellationToken.Register(p => asyncResult.Cancel(), null); return Task<IEnumerable<ListBlockItem>>.Factory.FromAsync( asyncResult, result => { registration.Dispose(); return blockBlob.EndDownloadBlockList(result); }); }
/// <summary> /// Creates a snapshot of the blob asynchronously. /// </summary> /// <param name="blockBlob">Cloud block blob.</param> /// <param name="metadata">A collection of name-value pairs defining the metadata of the snapshot.</param> /// <param name="accessCondition"> /// An <see cref="T:Microsoft.WindowsAzure.Storage.AccessCondition" /> object that represents the access conditions for the blob. If <c>null</c>, no condition is used. /// </param> /// <param name="cancellationToken">Cancellation token.</param> /// <returns> /// A blob snapshot. /// </returns> public static Task<CloudBlockBlob> CreateSnapshotAsync( this CloudBlockBlob blockBlob, IDictionary<string, string> metadata = null, AccessCondition accessCondition = null, CancellationToken cancellationToken = default (CancellationToken)) { ICancellableAsyncResult asyncResult = blockBlob.BeginCreateSnapshot(metadata, accessCondition, null, null, null, null); CancellationTokenRegistration registration = cancellationToken.Register(p => asyncResult.Cancel(), null); return Task<CloudBlockBlob>.Factory.FromAsync( asyncResult, result => { registration.Dispose(); return blockBlob.EndCreateSnapshot(result); }); }
/// <summary> /// Creates a page blob asynchronously. /// </summary> /// <param name="pageBlob">Cloud page blob.</param> /// <param name="size">The maximum size of the page blob, in bytes.</param> /// <param name="accessCondition"> /// An <see cref="T:Microsoft.WindowsAzure.Storage.AccessCondition" /> object that represents the access conditions for the blob. If <c>null</c>, no condition is used. /// </param> /// <param name="cancellationToken">Cancellation token.</param> public static Task CreateAsync( this CloudPageBlob pageBlob, long size, AccessCondition accessCondition = null, CancellationToken cancellationToken = default (CancellationToken)) { ICancellableAsyncResult asyncResult = pageBlob.BeginCreate(size, accessCondition, null, null, null, null); CancellationTokenRegistration registration = cancellationToken.Register(p => asyncResult.Cancel(), null); return Task.Factory.FromAsync( asyncResult, result => { registration.Dispose(); pageBlob.EndCreate(result); }); }
/// <summary> /// Aborts an ongoing blob copy operation asynchronously. /// </summary> /// <param name="cloudBlob">Cloud blob client.</param> /// <param name="copyId">A string identifying the copy operation.</param> /// <param name="accessCondition"> /// An <see cref="T:Microsoft.WindowsAzure.Storage.AccessCondition" /> object that represents the access conditions for the blob. /// </param> /// <param name="cancellationToken">Cancellation token.</param> public static Task AbortCopyAsync( this ICloudBlob cloudBlob, string copyId, AccessCondition accessCondition = null, CancellationToken cancellationToken = default (CancellationToken)) { ICancellableAsyncResult asyncResult = cloudBlob.BeginAbortCopy(copyId, accessCondition, null, null, null, null); CancellationTokenRegistration registration = cancellationToken.Register(p => asyncResult.Cancel(), null); return Task.Factory.FromAsync( asyncResult, result => { registration.Dispose(); cloudBlob.EndAbortCopy(result); }); }
/// <summary> /// Gets a reference to a blob in this container asynchronously. /// </summary> /// <param name="blobClient">Cloud blob client.</param> /// <param name="blobUri">The URI of the blob.</param> /// <param name="accessCondition"> /// An object that represents the access conditions for the container. If <c>null</c>, no condition is used. /// </param> /// <param name="cancellationToken">Cancellation token.</param> /// <returns> /// A reference to the blob. /// </returns> public static Task<ICloudBlob> GetBlobReferenceFromServerAsync( this CloudBlobClient blobClient, Uri blobUri, AccessCondition accessCondition = null, CancellationToken cancellationToken = default (CancellationToken)) { ICancellableAsyncResult asyncResult = blobClient.BeginGetBlobReferenceFromServer(blobUri, accessCondition, null, null, null, null); CancellationTokenRegistration registration = cancellationToken.Register(p => asyncResult.Cancel(), null); return Task<ICloudBlob>.Factory.FromAsync( asyncResult, result => { registration.Dispose(); return blobClient.EndGetBlobReferenceFromServer(result); }); }